1、变量类型

变量其实通过一个标记调用内存中的值，而变量名就是这个标记的名称，但是万一这个标记已经被提前占用或者解释器认为这个标记是不合法的，那么就会报错。

在C++中，有不同类型的变量，例如：

 1）整型（Integer Types）

int：存储整数，通常占用 4 个字节（32 位），范围约为 -2,147,483,648 到 2,147,483,647。

short：比 int 更小，通常占用 2 个字节（16 位），范围约为 -32,768 到 32,767。

long：比 int 更大，通常占用 4 或 8 个字节，取决于编译器和系统。

long long：更大的整数类型，至少占 8 个字节，适合存储非常大的整数。

无符号整数类型：unsigned 类型可以存储非负整数，如 unsigned int、unsigned short，其范围是相应类型的非负数范围。

#include <iostream>

int main() {
    int age = 25; // 常规整型
    short smallNumber = 32000; // 短整型
    long largeNumber = 1000000; // 长整型
    long long veryLargeNumber = 123456789012345LL; // 超长整型

    unsigned int positiveNumber = 300U; // 无符号整型

    std::cout << "int: " << age << "\n";
    std::cout << "short: " << smallNumber << "\n";
    std::cout << "long: " << largeNumber << "\n";
    std::cout << "long long: " << veryLargeNumber << "\n";
    std::cout << "unsigned int: " << positiveNumber << "\n";

    return 0;
}

2）浮点型（Floating Point Types）

float：单精度浮点数，通常占用 4 个字节，有约 6-7 位有效数字。

double：双精度浮点数，通常占用 8 个字节，有约 15 位有效数字。

long double：扩展精度浮点数，通常占用 10、12 或 16 个字节，具体取决于编译器。

#include <iostream>

int main() {
    float pi = 3.14159F; // 单精度浮点数
    double e = 2.718281828459045; // 双精度浮点数
    long double goldenRatio = 1.618033988749895L; // 扩展精度浮点数

    std::cout << "float: " << pi << "\n";
    std::cout << "double: " << e << "\n";
    std::cout << "long double: " << goldenRatio << "\n";

    return 0;
}

3）字符型（Character Types）

char：用于存储单个字符，通常占用 1 个字节（8 位），存储范围为 -128 到 127 或 0 到 255（具体取决于是否为无符号类型）。

unsigned char：无符号字符类型，范围为 0 到 255。

wchar_t：宽字符类型，用于存储 Unicode 字符，大小取决于系统，通常是 2 或 4 字节。

#include <iostream>

int main() {
    char letter = 'A'; // 字符型
    unsigned char unsignedLetter = 65; // 无符号字符型
    wchar_t wideChar = L'中'; // 宽字符类型

    std::cout << "char: " << letter << "\n";
    std::cout << "unsigned char: " << unsignedLetter << "\n";
    std::wcout << L"wchar_t: " << wideChar << L"\n";

    return 0;
}

4）布尔型（Boolean Type）

bool：布尔类型，存储 true 或 false，通常占用 1 个字节。

#include <iostream>

int main() {
    bool isHappy = true; // 布尔类型
    bool isSad = false;

    std::cout << "isHappy: " << isHappy << "\n";
    std::cout << "isSad: " << isSad << "\n";

    return 0;
}

5）空类型（Void Type）

void：表示无类型，一般用于函数返回类型表示不返回值，如 void myFunction();。

#include <iostream>

void sayHello() { // void 表示不返回任何值
    std::cout << "Hello, World!\n";
}

int main() {
    sayHello();
    return 0;
}

6）其他类型

auto：自动类型推导，编译器根据初始化的值推导出变量类型，如 auto x = 5.0; 会将 x 推导为 double 类型。

decltype：用于获取表达式的类型，如 decltype(a + b) 返回 a + b 的类型。

nullptr_t：表示空指针的类型，用于定义 nullptr 值。

#include <iostream>

int main() {
    auto number = 42; // 自动推导为 int 类型
    auto decimal = 3.14; // 自动推导为 double 类型

    decltype(number) anotherNumber = 100; // 使用 number 的类型，即 int
    decltype(decimal) anotherDecimal = 2.718; // 使用 decimal 的类型，即 double

    std::cout << "auto number: " << number << "\n";
    std::cout << "auto decimal: " << decimal << "\n";
    std::cout << "decltype anotherNumber: " << anotherNumber << "\n";
    std::cout << "decltype anotherDecimal: " << anotherDecimal << "\n";

    return 0;
}

7）自定义类型

结构体（struct）、联合体（union） 和 枚举（enum）：用于创建复杂的数据结构和枚举类型。

类（class）：面向对象编程的基础，用于创建对象和定义其属性和方法。

#include <iostream>

struct Person { // 结构体
    std::string name;
    int age;
};

union Data { // 联合体
    int integer;
    float decimal;
};

enum Color { // 枚举类型
    Red, Green, Blue
};

int main() {
    Person person = {"Alice", 30};
    Data data;
    data.integer = 42;

    Color favoriteColor = Green;

    std::cout << "Person name: " << person.name << ", age: " << person.age << "\n";
    std::cout << "Union integer: " << data.integer << "\n";
    std::cout << "Favorite color: " << favoriteColor << "\n";

    return 0;
}

2、定义声明变量

要创建变量，必须指定类型并为其分配值：

type variable = value;

在这里，type 必须是一个有效的 C 数据类型，可以是 char、w_char、int、float、double 或任何用户自定义的对象，也可以由一个或多个标识符名称组成，多个标识符之间用逗号分隔。下面列出几个有效的声明：

#include <iostream>
using namespace std;
extern int a,b;
extern int c;
extern float f;
int main () {
   int a,b;
   int c = -1;
   float f;
   a = 10;
   b = 20;
   c = a + b;
   printf("value of c : %d \n",c);
   f = 70.0/3.0;
   printf("value of f : %f \n",f);
   return 0;
}

可以在不分配值的情况下声明变量，然后在以后分配值：

int    i, j, k;
char   c, ch;
float  f, money;
double d;

3、变量名及命名规则

变量名的开头不能是数字，可以由字母或下划线开头。但，实际上编程中最常用的是以字母开头，而以下划线开头的变量名是系统专用的。

随便打开一个头文件就会看到，它里面所有的变量名、宏名、函数名全是以下划线开始的。

所以为了避免与系统定义的名字产生冲突，在编程的时候，除非要求这么定义，否则永远都不要使用下划线作为一个变量名的开头。

变量名以字母 A-Z 或 a-z 或下划线 _ 开头，后跟零个或多个字母、下划线和数字（0-9）。

变量名内不允许出现标点字符，比如 @、$ 和 %。C 是区分大小写的编程语言。例如，Cjavapy 和 cjavapy 是两个不同的标识符。

4、局部变量

局部变量是定义在函数体内部的变量，作用域仅限于函数体内部。离开函数体就会无效。再调用就是出错。

例如，

#include <iostream>
using namespace std;
int main(){
    int n = 30;  //局部变量
    //代码块由{}包围
    {
        int n = 40;  //局部变量
        printf("block n: %d\n", n);
    }
    printf("main n: %d\n", n);
    return 0;
}

5、全局变量

全局变量是定义在所有的函数外部定义的变量，它的作用域是整个程序，也就是所有的源文件。

#include <iostream>
using namespace std;
int n = 10;  //全局变量
void func1(){
    int n = 20;  //局部变量
    printf("func1 n: %d\n", n);
}
void func2(int n){
    printf("func2 n: %d\n", n);
}
void func3(){
    printf("func3 n: %d\n", n);
}
int main(){
    int n = 30;  //局部变量
    func1();
    func2(n);
    func3();
    //代码块由{}包围
    {
        int n = 40;  //局部变量
        printf("block n: %d\n", n);
    }
    printf("main n: %d\n", n);
    return 0;
}