C++Primer——第二章(变量和基础类型)

• 定义形式：类型说明符  + 一个或多个变量名组成的列表。（如int sum = 0, value, units_sold = 0）
• 初始化：对象在创建时获得了一个特定的值。
• 列表初始化：使用花括号{ }。（如int units_sold{0}）
• 默认初始化：定义时没有指定初始值会被默认初始化；在函数体内部的内置类型变量将不会被初始化。（建议初始化每一个内置类型的变量）

• 左值：可以出现在赋值语句的左边或者右边，比如变量。
• 右值：只能出现在赋值语句的右边，比如常量。
• 名字的作用域：同一个名字在不同的作用域中可能指向不同的实体。名字的有效区域 始于名字的声明语句，以声明语句所在的作用域末端为结束。

2.3 复合类型

• 必须初始化
• 无法重新绑定另一个对象（引用初始化后就和初始值 绑定 在一起了，而不是简单赋值）
• 只能绑定在对象上，而不能与字面值或某个表达式的计算结果绑定在一起

• 不能定义指向引用的指针（引用不是对象，没有实际地址）
• 不能访问一个没被初始化指针的值（没初始化的指针其值是不确定的）

int i = 42;
int &r = i;     // &紧随类型名出现，因此是声明的一部分，r是一个引用
int p;          // *紧随类型名出现，因此是声明的一部分，P是一个指针
P = &i;         // &出现在表达式中，是一个取地址符
*p = i;         // *出现在表达式中，是一个解引用符
int &r2 = *p;   // &是声明的一部分，*是一个解引用符 

int i = 1;
int *p;       // p是一个int型指针
int *&r = p;  // r是一个对指针p的引用（离变量名最近的符号(&)对变量类型有最直接的影响，因此r是一个引用，声明符的剩余部分(*)用以确定r的类型是什么，所以最终可知r引用的是一个指针） 

r = &i;       // r引用了一个指针，因此给r赋值&i就是令p指向i 
*r = 0;       // 解引用r得到i，也就是p指向的对象，将i的值改为0 

2.4 const限定符

(1) 初始化和const:

int i = 42;.
const int &r1 = i;        // 允许将 const int&绑定到一个普通 int对象上
const int &r2 = 42;       // 正确: r2是一个常量引用
const int &r3 = r1 * 2;   // 正确: r1、r3都是常量引用
int &r4=r1 * 2;           // 错误: r4是一个普通的非常量引用
const double& r5 = i;     // 正确: int可以转换为double类型

1. 在初始化常量引用时允许用任意表达式作为初始值，只要该表达式的结果能转换成引用的类型即可。
2. 允许为一个常量引用绑定非常量的对象、字面值、甚至是个一般表达式。

double i = 3.14;
const double* p = &i;     // 正确

int i = 1;
const int* p = &i;

int* ptr1 = p;         // 错误: "const int *"类型的值不能用于初始化"int *"类型的实体
const int* ptr2 = p;   // 正确

const int n = 1;

int &r1 = n;           // 错误: 将"int &"类型的引用绑定到"const int"类型的初始值设定项时，限定符被丢弃。
const int& r2 = n;     // 正确  

(5) constexpr和常量表达式

const int max_files = 20;           // max_files是常量表达式,
const int limit = max_files + 1;    // limit是常量表达式
int staff_size = 27;                // staff_size不是常量表达式（尽管staff_ size 的初始值是个字面值常量，但它的数据类型只是一个普通 int而非const int）
const int sz = get_size() ;         // sz不是常量表达式（尽管sz本身是一个常量，但它的具体值直到运行时才能获取到）

constexpr int mf = 20;          // 20是常量表达式.
constexpr int limit = mf + 1;   // mf + 1是常量表达式
constexpr int sz = size();      // 只有当size是一个constexpr函数时，才是一条正确的声明语句

int j = 0;
constexpr int i = 42;          // i的类型是整型常量
// 注: i和j都必须定义在函数体之外。

constexpr const int *p = &i;   // p是常量指针,指向整型常量i
constexpr int *p1 = &j;        // pl是常量指针,指向整数j

2.5 处理类型

(1) 类型别名

• 传统别名：使用typedef来定义类型的别名。（如：typedef double wages；）
• 新标准别名：使用using来定义类型的别名。（如： using SI = Sales_item;（C++11）)

typedef char *pstring;

const patring cstr=0;     // cstr是指向char的常量指针（const修饰pstring这个指针(char *)，所以数据类型为 const char*，因此cstr是指向char常量指针）
const char *cstr=0;       // cstr是指向一个常量对象的指针（const修饰char，所以数据类型为const char ,因此cstr是指向一个常量对象的指针）

(2)auto类型说明符

const int a = 1;
auto b = a;       // b为 int 类型（忽略顶层const属性）
auto c = &a;      // c是 const int* 类型（保留底层const属性）

const int a = 1;
const int& y = a;
auto b = y;        // b为 int 类型（实际推导的是引用所绑定的对象，并忽略顶层const属性）

const int a = 1; 
auto& y = a;       // y为const int类型的引用（保留了a的顶层const，而y本身变成了底层const）

auto &q = a, *p = &a;    // 正确: q是对const int的引用，p是指向const int的指针
auto &c = b, *d = &a;    // 错误: c的数据类型为int，d的数据类型为const int

(3)decltype类型指示符

const int i = 0, &j = i;     // i为const int，j为const int&

decltype(i) x = 0;     // x的类型是const int
decltype(j) y = x;     // y的类型是const int&

int i = 42, *p = &i, &r = i;    // i是int类型变量，p是int类型指针，r是int类型引用（它们类型都为int，只是声明符不同而已）

decltype(r + 0) b;       // b为int（算术表达式返回右值，即int）
decltype((i)) ri = i;    // ri为int&（加了括号变量i变成了表达式，因此返回的是i的左值形式，即int&）
decltype(*p) c = i;      // c是一个int类型引用

• 解引用运算符*作用于指针类型，得到了p指向的对象的左值。因此decltype(*p)得到的类型是int &。
• 当变量i 加一个括号后，是作为表达式 。返回的是该变量的一个左值形式。（因为该表达式的结果可以作为赋值语句的左侧的值，所以是左值，因此得到类型的左值引用）

int fun(int a,int b);
decltype(fun) *pf = fun;      // pf为int(*)(int,int)类型

2.6 自定义数据结构

• 可以为类数据成员提供一个 类内初始值（C++11）。
• 当预处理器看到#include标记时，会用指定的头文件内容代替#include
• 头文件：通常包含那些只能被定义一次的实体：类、const和constexpr变量。
• 预处理器：确保头文件多次包含仍能安全工作。
• 头文件保护符：依赖于预处理变量的状态：已定义和未定

#ifndef SALES_DATA_H     
#define SALES_DATA_H
strct Sale_data{
    ...
}
#endif