C++ 笔记（05）— 变量（变量定义、声明、初始化、extern关键字、变量之间转换）

1. 变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type variable_list;

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

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

2. 变量初始化

2.1 明确变量类型初始化

变量可以在定义的时候被初始化（指定一个初始值）。初始化器由一个等号，后跟一个常量表达式组成，如下所示：

type variable_name = value;

示例：

extern int d = 3, f = 5;    // d 和 f 的声明 
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z
char x = 'x';               // 变量 x 的值为 'x'

2.2 使用auto 自动推断类型

如果将变量的初值设置成了 true ，就可推断其类型为 bool 。如果您使用的编译器支持 C++11 和更高版本，可不显式地指定变量的类型，而使用关键字 auto ：

auto flag = true

这将指定变量 flag 的类型的任务留给了编译器。编译器检查赋给变量的初值的性质，再确定将变量声明为什么类型最合适。

#include <iostream>
using namespace std;

int main()
{
    auto flag = true;
    auto num = 100;
    cout << "flag sizeof is " << sizeof(flag) << endl;	// flag sizeof is 1
    cout << "num sizeof is " << sizeof(num) << endl; 	// num sizeof is 4
}

注意：使用 auto 时必须对变量进行初始化，因为编译器需要根据初始值来确定变量的类型。如果将变量的类型声明为 auto ，却不对其进行初始化，将出现编译错误。

2.3 默认初始化

你可能已经注意到了 , 我们通常不对 string 、 vector 等对象进行初始化 。 例如 :

vector<string> v;
string s;
while (cin >> s) 
{
	v.push_back(s);
}

这并不是 “变量必须先初始化再使用 ” 这条规则的例外情况 。 之所以出现这种情况，是因为我们定义 string 类型和 vector 类型时定义了默认初始化机制 ， 如果代码中不显式进行初始化 ，这两种对象就会被用一个默认值进行初始化 。 因此 ，上述代码执行到循环时， v 的值为空 (不包含任何元素)， s 的值为空串 "" 。 保证默认初始化的机制称为默认构造函数。

不幸的是 , C++不允许我们对内置类型设置默认初始化功能 。 全局变量会被默认初始化为 0 , 但你应该尽量少用全局变量 。而最常使用的变量—局部变量和类成员，是不会被初始化的 , 除非你对其进行初始化 (或提供一个默认构造函数 )。

3. 变量声明

变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

当使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。

虽然您可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。

代码示例：

#include <iostream>

using namespace std;

// 变量声明
extern int a, b;
extern int c;
extern float f;

int main()	
{
    // 变量定义
    int a, b;
    int c;
    float f;

    // 初始化
    a = 10;
    b = 20;
    c = a + b;
    cout << "c is " << c << endl;

    f = 10/3.0;
    cout << "f is " << f << endl;

    return 0;
}

4. 定义与声明区别

定义包含了声明，但是声明不包含定义，如：

int a = 0;     //定义并初始化变量 a，同时也就声明了 a
extern int a;  //只是声明了有一个变量 a 存在，具体 a 在哪定义的，需要编译器编译的时候去找。

函数也是类似，定义的时候同时声明。但如果只是声明，编译器只知道有这么个函数，具体函数怎么定义的要编译器去找。

void fun1();  //函数声明

void fun1(){  //函数定义
    cout<<"fun1"<<endl;
}

注意：
C/C++ 编译 cpp 文件是从上往下编译，所以 main 函数里面调用其他函数时，如果其他函数在 main 函数的下面，则要在 main 函数上面先声明这个函数。或者把 main 函数放在最下面，这个不仅限于 main 函数，其他函数的调用都是如此。被调用的函数要在调用的函数之前声明 。

5. extern 关键字

extern 关键字在变量和函数之前声明。

5.1 作用在变量之前

变量只允许定义一次，但可以在多个文件中声明。
test.cpp 中：

int a = 0;     // 定义一个变量 a，并赋初值为 0

test1.cpp 中：

extern int a;  // 声明变量 a，它在 test.cpp 中被定义，此处不可赋值

test2.cpp 中：

extern int a;  // 声明变量 a,它在 test.cpp 中被定义，此处不可赋值

5.2 作用在函数之前

test.h：

extern void Fun();   // 函数声明，extern 用于标识此函数为外部可调用函数

test.cpp：

void Fun();  // 函数定义

5.3 定义函数体内会报错

示例：

#include <iostream>

using namespace std;

int main()	
{
    extern int a = 10;
    cout << "a is " << a << endl;
    return 0;
}

编译错误信息：

main.cpp: In function ‘int main()’:
main.cpp:7:16: error: ‘a’ has both ‘extern’ and initializer
     extern int a = 10;

6. 变量之间转换

变量的类型间是可以互相转换的，转换又分为自动转换和强制转换。

6.1 自动转换

• 若参与运算量的类型不同，则先转换成同一类型，然后进行运算；
• 转换按数据长度增加的方向进行，以保证精度不降低。如 int 型和 long 型运算时，先把 int 转成 long 型后再进行运算。

a、若两种类型的字节数不同，转换成字节数高的类型 ；
b、若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型；

• 所有的浮点运算都是以双精度进行的，即使仅含 float 单精度量运算的表达式，也要先转换成 double 型，再作运算；
• char 型和 short 型参与运算时，必须先转换成 int 型；
• 在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度；

#include <iostream>
using namespace std;

int main()	
{  
    int a=1;
    double b=2.5;
    a=b;
    cout << "a is " << a << endl; //输出为 2，丢失小数部分

    int c = 1;
    double d = 2.1;
    cout << "c + d = " << c + d << endl;  //输出为c + d = 3.1

    return 0;
}

6.2 强制转换

强制类型转换是通过类型转换运算来实现的。其一般形式为：（类型说明符）（表达式）其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。

#include <iostream>
using namespace std;

int main()	
{  
    int a = 1;
    double b = 2.1;
    cout << "a + b = " << a + (int)b << endl;  //输出为a + b = 3

    return 0;
}

6.3 使用列表初始化避免缩窄转换错误

使用取值范围较大的变量来初始化取值范围较小的变量时，将面临出现缩窄转换错误的风险，因为编译器必须将大得多的值存储到容量没那么大的变量中，下面是一个这样的示例：

int largeNum = 5000000;
short smallNum = largeNum; // compiles OK, yet narrowing error

缩窄转换并非只能在整型之间进行，但如果使用 double 值来初始化 float 变量、使用 int 值来初始化 float 或 double 变量，或者使用 float 值来初始化 int 变量，可能导致缩窄转换错误。

有些编译器可能发出警告，但这种警告并不会导致程序无法通过编译。

为避免这种问题， C++11 引入了列表初始化来禁止缩窄。要使用这种功能，可将用于初始化的变量或值放在大括号（ {} ）内。列表初始化的语法如下：

int largeNum = 5000000;
short anotherNum{ largeNum }; // error! Amend types
int anotherNum{ largeNum }; // OK!
float someFloat{ largeNum }; // error! An int may be narrowed
float someFloat{ 5000000 }; // OK! 5000000 can be accomodated

这种功能的作用虽然不明显，但可避免在执行阶段对数据进行缩窄转换导致的 bug，这种 bug 是不合理的初始化导致的，难以发现。