C++变量
C++变量
一、变量的声明和定义
1.1 变量的定义
变量定义的格式为
type name; // 定义type类型变量name，默认初始化
或者：
type name = value; // 定义type类型变量name，并设置初始值为value
类型说明符 变量名
例如：
// 下面的定义没有给初始值，所以变量会被默认初始化
int a;
bool b;
char c;
double d;
long l;
short s;
// 定义整型变量并设置初始值为1
int a = 1;
注意：定义在函数体外的内置类型变量会被初始化为0；
定义在函数体内部的内置类型变量不会被初始化，所以值是未定义的；使用该值可能会发生错误。
1.2 初始化和赋值
初始化是创建变量的时候赋予其一个初值；
赋值是把对象的当前值擦除，赋予其一个新值；
1.3 声明和定义的关系
声明是指把名字告知程序，使得程序知道该名字。
定义是负责创建与名字关联的实体。
声明和定义都规定了变量的类型和名字，但是声明不会为变量申请存储空间，定义会为变量申请内存空间，也可能会为变量赋初值。
包含了显示初始化的声明自动变为定义。
变量只能被定义依次，但是可以多次声明。
声明变量的方法：
extern int i; //声明一个整型变量i
int j; //声明并定义j
extern int k = 0; //声明并定义k
2 标识符
C++标识符右字母、下画线、数组组成；
必须以字母或者下画线开头，不能数字开头，长度没有限制，大小写敏感。
3 变量的作用域
变量的作用域起始于名字的声明语句，以声明语句所在的作用域末端结束
int i; //i是一个全局变量，在整个程序中有效
void test()
{
int i; //i是一个局部变量，在函数test的函数体内有效，同时这个局部的变量i覆盖了上面的全局变量i，如果在函数体内想要使用全局的i可以加上全局作用域符::i来使用
}
4 符合类型变量
4.1 引用
引用就是给变量起一个别名，用法变量原来的名字是完全相同的。
格式：
int i = 0;
int& r1 = i; //r是i的一个引用，也就是一个别名
int& r2 = r1; //正确，r2是i的另一个引用，r2,r1,i代表相同的变量
定义引用时必须初始化，否则无法知道引用的是哪个变量，编译出错。
引用只能绑定在对象上，不能绑定字面值或者表达式的计算结果。
4.2 指针
指针是指向某种类型的变量，其值代表其指向变量的地址。
指针本身也是一个对象，允许赋值和拷贝，可以执行不同的对象。
指针在定义时可以不给初始值；
格式：
int* p; // p是一个int型指针，指向一个int型的对象
int i = 0;
int* pi = &i; //p是一个int型指针，指向i
4.2.2 通过指针访问对象
如果想要通过指针来访问（获取值，修改值等）对象，对指针使用*(解引用)操作符就可以
int i = 0;
int* p = &i;
*p = 10; // 把p指向的对象的值赋为10，此时i的值变为10；
cout << *p << endl; // 把p指向对象的值打印到标准输出流，屏幕输出10；
4.2.3 指针赋值
不使用*(解引用)运算符时，给指针赋值，是改变了指针所指向的地址
int i = 0;
int* p = &i; // 让p指向i；
int a = 10;
p = &a; // 让p重新指向a；
4.2.4 指向指针的指针
因为引用本身不是对象，所以指针不能指向引用，但是指针可以指向指针
int i = 0;
int* p = &i; // p是指针，指向int类型的i
int** pp = &p; // pp是指针的指针，指向int*类型的p
5 const修饰符
const 是常量修饰符，有const修饰的变量，其值不能被修改；实现只读效果
const修饰的变量，其值不能被修改，所以必须要在定义的时候进行初始化。
const int i = 42;// 正确，i是一个常变量，其值只读，不可修改
const int j; // 错误，常变量必须在定义时初始化
默认状态下，const对象只在本文件内有效，如果想在多个文件之间共享const对象，必须在变量的定义之前添加extern关键字。
5.1 const的引用
const的引用，可以绑定任意表达式作为初始值（非const的引用只能绑定到对象上），，const引用可以绑定非常量对象，字面值，甚至是一般表达式。
int i = 10;
const int& r1 = i; //正确
const int& r2 = r1 * 10; //正确
const int& r3 = 42; //正确
int& r4 = r1 * 10; //错误
5.2 const和指针
5.2.1 指向常量的指针
指针可以指向常量，指向常量的指针，不能用于改变其所指对象的值，如果想存放常量对象的地址，只能使用指向常量的指针。
const int i = 10;
int* pi = &i; // 错误，pi不是一个指向常量的指针，但是其指向的变量是一个常变量
const int* ptr = &i; //正确，ptr是一个指向常整型变量的指针
*ptr = 20; // 错误，不能对指向常量的指针执行的对象进行赋值
const修饰的指针，可以指向非常量，但是此时不能通过指针修改指向对象的值
double d = 3.14;
const double* p = &d; //正确，p是指向d的一个指针，但是通过这个指针只能对d进行只读操作，不能进行修改操作
d = 2.718; // 此时，可以通过其他方法修改d的值
5.2.2 const指针
指针本身是一个变量，const也可以作用与指针本身，此时指针为常量指针，也就是指针的值（指针指向的地址）不能变化。
int i = 10;
int a = 20;
int* const p = &i; // 正确，p指向i，同时p的值不能改变，也就是p不能重新指向别的对象
*p = 20; // 正确，可以通过指针修改指向对象的值
p = &a; //错误，p是const类型的指针，其值（指向的地址）不能被修改
5.2.3 顶层const和底层const
对于指针来说，const可以用来说明指针本身是常量（顶层const）或者指针指向常量（底层const）
对于引用来说，const全部都是底层const（也就是说是对常量的引用）
int i = 10;
const int* p1 = &i; // 底层const，用来说明指针指向常量（只读，不能通过指针修改指向对象的值）
int* const p2 = &i; // 顶层const，用来说明指针是一个常量（不能指向别的地址）
const int& r1 = i; // 底层const，用来说明是对常量的引用（只读，不能通过引用来修改对象的值）
一般地，在赋值时，顶层const不对赋值产生影响，但是底层const的变量不能赋值给非底层const的变量
int i = 10;
const int* p1 = &i;
int* const p2 = &i;
int* p3 = p1; // 错误，p1具有底层const，其指向的是常量（只读，不对其指向的对象进行修改），而p3不具有底层const，其指向的不是常量（非只读，可以通过其对指向的对象进行修改）
int* p4 = p2; // 正确，p2具有顶层const，代表p2是常指针，可以把p2指向的地址赋给p4
5.2.4 constexpr变量
常量表达式是指值不会改变，并且在编译过程就能得到计算结果的表达式。
C++11允许将变量声明为constexpr类型以便由编译器验证变量的值是否是一个常量表达式。声明为constexpr的变量一定是一个常量，并且必须用常量表达式初始化
constexpr int i = 20;
constexpr int limit = i + 1;
constexpr int sz = size(); //当size是一个constexpr函数时正确
constexpr作用于指针时，仅对指针有效，与指针所属的对象无关
const int* p = nullptr; //p是一个指向常量整型的指针
constexpr int* q = nullptr; // q是一个指向整型的常量指针，constexpr把它定义的对象限定为顶层const
6.变量类型
6.1 类型别名
typedef unsigned int size_t; //size_t是unsigned int 的别名
using ui = unsigned int; //ui是unsigned int的别名
size_t sz = 10; // sz是unsigned int类型变量
ui i = 10; // i是unsigned int类型变量
指针类型的别名和const一起使用时，const会被认为是顶层const而不是底层const
typedef char* pstchar;
const pstchar pc; // 此时，pc是常量指针，而不是指向常量的指针，const是顶层const
6.2 auto说明符
当要将一个复杂表达式的结果赋值给某个变量，必须要清楚的知道表达式结果的类型并在声明是写出该类型，对于比较复杂的表达式，并不是一件容易的事。
C++11新标准引入了auto类型说明符，可以让编译器帮助判断表达式结果类型
auto a = 10; // a是整型
auto sz = 0, pi = 3.14; // 这种声明是错误的，因为编译器判断0是整型，3.14是double型，无法确定auto实际应该代表的类型
auto一般会忽略顶层的const，同时底层的const会保留
int i = 0;
const int ci = 10, &cr = i;
auto a = ci; // ci具有顶层const，auto会忽略，a是一个整型变量
auto b = cr; // cr是ci的引用，相当于把ci赋值给b，b是一个整型变量
auto c = &i; // c是一个整型指针，指向整型变量
auto d = &ci; // d是一个指向常量的指针，因为ci具有底层const，
如果需要auto推断出的类型具有顶层const，需要明确指出：
const auto e = ci; // e是一个常整型（const int）
6.3 decltype类型指示符
decltype 可以根据表达式返回类型，不用计算表达式的值
decltype(size()) sz = 10; // sz的类型是size函数的返回值的类型
decltype在得出变量类型时会保留其顶层const和引用
const int ci = 0, &cr = ci;
decltype(ci) x = 0; // x是const int类型
decltype(cr) y = x; // y是const int&类型，绑定到x
decltype(cr) z; // 错误，z是引用，必须初始化
decltype的表达式如果是对指针解引用操作，那么得到的将是一个引用类型
int i = 10;
int* p = &i;
decltype(*P) a = i; //a是一个整型的引用，如果不初始化，会报错
decltype的结果类型和表达式密切相关，如果对变量名加上括号，那么得到的将是该变量类型的引用
int i = 10;
decltype(i) a; //a是一个int型变量
decltype((i)) b; // 错误，b是一个整型引用，必须初始化