《C++ Primer》学习笔记（二）：变量和基本类型

谁践踏了优雅 2023-05-22 10:22 3阅读 0赞

### 《C++ Primer》学习笔记（二）：变量和基本类型 ###

*  基本内置类型
 *   *  算数类型
     *  类型转换
     *  字面值常量
 *  变量
 *   *  变量声明和定义的关系
     *  变量命名规则
     *  作用域
 *  复合类型
 *   *  引用
     *  指针
 *  const限定符
 *   *  const的引用
     *  指针和const
     *  顶层const
     *  constexpr和常量表达式
     *  用const修饰函数的参数
     *  用const修饰函数的返回值
     *  const 成员函数
 *  处理类型
 *   *  类型别名
     *  auto类型说明符
     *  decltype类型指示符
 *  自定义数据结构
 *  练习

C++ 语言定义了几种基本类型：\*\*字符型、整型、浮点型 \*\*等；除此之外，还提供了可用于 **自定义数据类型** 的机制，标准库正是利用这些机制定义了许多更复杂的类型，比如 \*\*可变长字符串 string、vector \*\*等；最后，还能修改已有的类型以形成 复合类型。

# 基本内置类型 #

C++ 定义了一组表示 整数、浮点数、单个字符 和 布尔值 的算术类型，另外还定义了一种称为 空类型（void） 的特殊类型。

## 算数类型 ##

算数类型分为两类：整型（integral type， 包括字符和布尔类型在内）和浮点型。C++ 标准规定了每个算术类型的最小存储空间，但它并不阻止编译器使用更大的存储空间。各类型的最小存储空间如下表所示：  
![内置算术类型及其对应的最小存储空间][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70]  
在整型类型大小方面，C++ 规定 `short`≤ `int`≤ `long`≤ `long long`（`long long` 是C++11定义的类型）。

*  当明确知晓数值不可能为负时，应该使用无符号类型。
 *  使用 `int` 执行整数运算，不易出错，如果数值超过了 int 的表示范围，应该使用 `long long`类型。
 *  在算数表达式中不要使用 `char`和`bool`类型。如果需要使用一个不大的整数，应该明确指定它的类型是 `signed char`还是`unsigned char`。
 *  执行浮点数运算时建议使用 `double` 类型，基本上不会有错。

## 类型转换 ##

*  把非布尔类型的算术值赋给布尔类型时，初始值为0则结果为 `false`，否则结果为`true`。
 *  把布尔值赋给非布尔类型时，初始值为 `false` 则结果为0，初始值为`true` 则结果为1。
 *  把浮点数赋给整数类型时，进行近似处理，结果值仅保留浮点数中的整数部分。
 *  把整数值赋给浮点类型时，小数部分记为0。如果该整数所占的空间超过了浮点类型的容量，精度可能有损失。
 *  赋给无符号类型一个超出它表示范围的值时，结果是初始值对无符号类型表示数值总数（8比特大小的 `unsigned char`能表示的数值总数是256）取模后的余数。
 *  赋给带符号类型一个超出它表示范围的值时，结果是 **未定义的（undefined）**。

**注意：不要混用带符号类型和无符号类型。**

## 字面值常量 ##

一个形如58的值被称作**字面值常量(literal)**，这样的值一望便知。每个字面值常量都对应一种数据类型，字面值常量的形式和值决定了它的数据类型。

我们可以将整型字面值写作十进制数、八进制数或十六进制数的形式。以`0`开头的整数代表**八进制数**，以`0x`或`0X`开头的代表**十六进制数**。在C++14中，`0b`或 `0B` 开头的整数代表 **二进制（binary）数**。默认情况下，十进制字面值是带符号数，八进制和十六进制字面值既可能是带符号的也可能是无符号的。浮点型字面值默认是一个 `double`。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 1]

**1) 整型字面值**

*  在数值后面加 `L`或者 `l`指定常量为 long 类型。（定义长整型时，应该使用大写字母`L`。小写字母 `l`很容易和数值 1 混淆。）
 *  在数值后面加 `U` 或 `u`定义 `unsigned` 类型。
 *  同时加`L` 和 `U`就能够得到 `unsigned long` 类型的字面值常量。

328u    /* unsigned */
    014UL   /* unsigned long*/
    1L 	 	/* long */
    8Lu 	/* unsigned long*/

**2) 浮点型字面值**  
浮点型字面值默认是一个 `double`。浮点型字面值表现为一个小数或以科学计数法表示的指数，其中指数部分用`E`或`e`标识,在数值的后面加上 `F`或 `f`表示单精度。

3.1415926   3.14159E0    0.     0e0    .001    3.14159F  3.14159E0f    .001f

**3) 字符和字符串字面值**  
由单引号括起来的一个字符称为 `char` 型字面值，双引号括起来的零个或多个字符称为字符串字面值。在字符字面值前加 `L`就能够得到 `wchar_t`类型的宽字符字面值。

'a' //字符字面值
    L'a'  //宽字符字面值
    "Hello world"  //字符串字面值

字符串字面值的类型实际上是由常量字符构成的数组（array）。为了兼容 C 语言，C++ 中所有的字符串字面值都由编译器自动在末尾添加一个空字符 `'\0'`，因此字符串字面值的实际长度要比它的内容多一位。

#include <iostream>
    int main()
    {
        
    
        std::cout << "Hello World!" <<std::endl;				// 文字简单字符串
        std::cout << "---------------" <<std::endl;
        std::cout << "" 		<<std::endl;					// 文本空字符串
        std::cout << "---------------" <<std::endl;
        std::cout << "\nCC\toptions\tfile.[cC]\n" <<std::endl;	// 文字字符串 using newlines and tabs
        std::cout << "---------------" <<std::endl;
    
    	return 0;
    }

![在这里插入图片描述][20200417165809468.png]  
**4) 转义序列**

转义序列均以反斜线开头，C++语言规定的转义序列包括：  
![在这里插入图片描述][20200417172205401.png]

std::cout << '\n';      // prints a newline
    std::cout << "\tHi!\n"; // prints a tab 跟着是 "Hi!" and a newline

# 变量 #

定义时可以为一个或多个变量赋初始值，即 **初始化（initialization）**。

用花括号初始化变量称为 列表初始化（list initialization）。当用于内置类型的变量时，如果使用了列表初始化并且初始值存在丢失信息的风险，则编译器会报错。

long double ld = 3.1415926536;
    int a{
        ld}, b = {
        ld};    // error: 转换未执行，因为存在丢失信息的危险
    int c(ld), d = ld;      // ok: 转换执行，且确实丢失了部分值

如果定义变量时未指定初值，则变量被 **默认初始化（default initialized）**。对于内置类型，定义于任何函数体之外的变量被初始化为0，函数体内部的变量将不被 **初始化（uninitialized）**。

每个类各自决定其初始化对象的方式。而且，是否允许不经初始化就定义对象也由类自己决定。定义于函数体内的内置类型对象如果没有初始化，则其值未定义，使用该类值是一种错误的编程行为且很难调试。类的对象如果没有显示的初始化，则其值由类确定。

建议初始化每一个内置类型的变量。

## 变量声明和定义的关系 ##

**声明（declaration）** 使得名字为程序所知。一个文件如果想使用其他地方定义的名字，则必须先包含对那个名字的声明。

**定义（definition）** 负责创建与名字相关联的实体。

如果想声明一个变量而不定义它，就在变量名前添加关键字 `extern`，并且不要显式地初始化变量。

extern int i; // 声明但不定义 i
    int j;      // 声明并定义 j

`extern`语句如果包含了初始值就不再是声明了，而变成了定义。

变量能且只能被定义一次，但是可以被声明多次。

**如果要在多个文件中使用同一个变量，就必须将声明和定义分开。此时变量的定义必须出现且只能出现在一个文件中，其他使用该变量的文件必须对其进行声明，但绝对不能重复定义。**

## 变量命名规则 ##

*  变量名一般用小写字母，如index
 *  用户自定义的类名一般以大写字母开头，如Sales\_item
 *  如果标识符由多个单词组成，则单词间需要有明显的区分。如student\_loan

## 作用域 ##

#include <iostream>
    // 该程序仅用于说明: 函数内部不宜定义与全局变量同名的新变量
    int reused = 42;  // reused拥有全局作用域
    int main()
    {
        
    	int unique = 0; // unique拥有块作用域
    	// output #1: 使用全局变量reused; prints 42 0
    	std::cout << reused << " " << unique << std::endl;
    	int reused = 0; // 新建局部变量reused，覆盖了全局变量reused
    	// output #2: 使用局部变量reused; prints 0 0
    	std::cout << reused << " " << unique << std::endl;
    	// output #3: 显式访问全局变量reused; prints 42 0
    	std::cout << ::reused << " " << unique << std::endl;
    	system("pause");
    	return 0;
    }

可以用作用域操作符 `::`来覆盖默认的作用域规则。因为全局作用域本身并没有名字，所以当作用域操作符的左侧为空时，会向全局作用域发出请求获取作用域操作符右侧名字对应的变量。

# 复合类型 #

## 引用 ##

int ival = 1024;
    int &refVal = ival; // refval是指ival
    int &refVal2;       // error: 必须初始化引用

定义引用时，程序把引用和它的初始值绑定（bind）在一起，而不是将初始值拷贝给引用。一旦初始化完成，将无法再令引用重新绑定到另一个对象，因此 **引用必须初始化**。

引用并非对象，相反的，它只是为一个已经存在的对象所起的另外一个名字。

定义一个引用后，对其进行的所有操作都是在与之绑定的对象上进行的。为引用赋值，实际上是赋值给了其绑定的对象；获取引用的值，实际上是获取了其绑定的对象的值；以引用作为初始值，实际上以其绑定的对象作为初始值。

因为引用本身不是一个对象，所以不能定义引用的引用。

引用只能绑定在对象上，不能与字面值或某个表达式的计算结果绑定在一起。

在一个类型定义行中定义多个引用时必须在每个引用标识符前添加 & 符号：

int i = 1024, i2 = 2048;
    int &r = i, r2 = i2; 	 // r是引用，r2是int
    int i3 = 1024, &ri = i3; // 定义一个对象和一个引用
    int &r3 = i3, &r4 = i2;  // 定义两个引用

## 指针 ##

*  指针本身就是一个对象，允许对指针赋值和拷贝，而且在生命周期内它可以先后指向不同的对象。
 *  指针无须在定义时赋初值。和其他内置类型一样，在块作用域内定义的指针如果没有被初始化，也将拥有一个不确定的值。

如果在一条语句中定义了多个指针变量，则每个量前都必须有符号 \*。

int *ip1, *ip2;     // ip1和ip2都是指向int对象的指针
    double dp, *dp2;    // dp2是指向double对象的指针；dp是double对象

指针存放某个对象的地址，要想获取对象的地址，需要使用取地址符 `&`。

int ival = 42;
    int *p = &ival; // p保存ival的地址；p是指向ival的指针

如果指针指向一个对象，可以使用 解引用（dereference）符 \* 来访问该对象。

int ival = 42;
    int *p = &ival; // p存放着变量ival的地址，或者说p是指向变量ival的指针
    cout << *p;     // 由符号*得到指针p所指的对象，输出42

指针和引用都能提供对其他对象的间接访问，然而在具体实现细节上二者有很大不同，其中最重要的一点就是 引用本身并非一个对象。一旦定义了引用，就无法令其再绑定到另外的对象，之后每次使用这个引用都是访问它最初绑定的那个对象。指针和它存放的地址之间就没有这种限制了。和其他任何变量(只要不是引用) 一样，给指针赋值就是令它存放一个新的地址，从而指向一个新的对象。

建议初始化所有指针,如果实在不清楚指针应该指向何处， 就把它初始化为 nullptr。关于nullptr可参考：[【C++11新特性】 nullptr关键字][C_11_ nullptr]

# const限定符 #

`const`变量必须被初始化。

const int i = get_size(); //正确：运行时初始化
        const int j = 42; //正确：编译时初始化
        const int k; //错误：k是一个未经初始化的常量

默认情况下，`const`对象被设定成仅在文件内有效。当多个文件中出现了同名的 `const`变量时，其实等同于在不同文件中分别定义了独立的变量。

如果想在多个文件间共享`const` 对象：

*  若`const`对象的值在编译时已经确定，则应该定义在头文件中。其他源文件包含该头文件时，不会产生重复定义错误。
 *  若 `const`对象的值直到运行时才能确定，则应该在头文件中声明，在源文件中定义。此时`const`变量的声明和定义前都应该添加 `extern`关键字。

// file_1.cc定义并初始化了一个常量，该常量能被其他文件访问
    extern const int bufSize = fcn();
    // file_1.h头文件
    extern const int bufSize;   // 与file_1.cc中定义的bufSize是同一个

## const的引用 ##

可以将引用绑定到const对象上，称为**对常量的引用**。与普通引用不同的是，对常量的引用不能被用于修改它所绑定的对象。

const int ci = 1024;
    const int &r1 = ci;     // ok: 引用及其对应的对象都是常量
    r1 = 42;        		// error: r1是对常量的引用
    int &r2 = ci;   		// error: 试图让一个非常量引用指向一个常量对象

大部分情况下，引用的类型要和与之绑定的对象严格匹配。但是有两个例外（第二个例外在第十五章）：

第一个例外就是初始化常量引用时，允许用任意表达式作为初始值，只要该表达式的结果能转换成引用的类型即可。

int i = 42;
    const int &r1 = i;      // 允许将const int&绑定到一个普通int对象上
    const int &r2 = 42;     // ok: r1是一个常量引用
    const int &r3 = r1 * 2; // ok: r3是一个常量引用
    int &r4 = r1 * 2;       // error: r4是一个普通的非常量引用

## 指针和const ##

const double pi = 3.14;     // pi是个常量，它的值不能改变
    double *ptr = π          // error: ptr是一个普通指针
    const double *cptr = π   // ok: cptr可以指向一个双精度常量
    *cptr = 42;         	    // error: 不能给*cptr赋值
    double dval = 3.14; 		// dval是一个双精度浮点纹，它的值可以改变
    cptr = &dval;       		// ok: 但是不能通过cptr改变dval的值

常量指针必须初始化，而且一旦初始化完成，则它的值（即存放在指针中的那个地址）就不能再改变了。把`*`放在`const`关键字之前用以说明指针是一个常量。指针本身是常量并不代表不能通过指针修改其所指向的对象的值，能否这样做完全依赖于其指向对象的类型。

int errNumb = 0;
    int *const curErr = &errNumb;   // curErr将一直指向errNumb
    const double pi = 3.14159;
    const double *const pip = π  // pip是一个指向常量对象的常量指针

## 顶层const ##

顶层 `const` 表示指针本身是个常量，底层 `const（low-level const）`表示指针所指的对象是一个常量。指针类型既可以是顶层 `const`也可以是底层 `const`。

当执行拷贝操作时，常量是顶层 const 还是底层 const 区别明显：

*  顶层 const 没有影响。拷贝操作不会改变被拷贝对象的值，因此拷入和拷出的对象是否是常量无关紧要。
 *  底层const的限制不能忽视。拷入和拷出的对象必须具有相同的底层 const 资格。或者两个对象的数据类型可以相互转换。一般来说，非常量可以转换成常量，反之则不行。

## constexpr和常量表达式 ##

**常量表达式（constant expressions）** 指值不会改变并且在编译过程就能得到计算结果的表达式。显然，字面值属于常量表达式，用常量表达式初始化的const对象也是常量表达式。

const int max_files = 20;           // max_files是常量表达式
    const int limit = max_files + 1;    // limit是常量表达式
    int staff_size = 27;        	    // staff_size不是常量表达式
    const int sz = get_size();  		// sz 不是常量表达式

尽管staff\_size的初始值是一个字面值常量，但是它的数据类型只是一个普通int而非const int，所以它不属于常量表达式。而sz的数据类型虽然是常量，但是它的具体值直到运行时才能获得，所以也不是常量表达式。

C++11允许将变量声明为`constexpr`类型以便由编译器来验证变量的值是否是一个常量表达式。

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

指针和引用都能定义成 `constexpr`，但是初始值受到严格限制。`constexpr` 指针的初始值必须是0、`nullptr` 或者是存储在某个固定地址中的对象。函数体内定义的普通变量一般并非存放在固定地址中，因此`constexpr`指针不能指向这样的变量。相反，函数体外定义的变量地址固定不变，可以用来初始化 constexpr 指针。

`const` 和 `constexpr` 限定的值都是常量。但 `constexpr`对象的值必须在编译期间确定，而 const 对象的值可以延迟到运行期间确定。建议使用 `constexpr`修饰表示数组大小的对象，因为数组的大小必须在编译期间确定且不能改变。

## 用const修饰函数的参数 ##

如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const修饰，否则该参数将失去输出功能。const只能修饰输入参数。**如果输入参数采用“指针传递”，那么为指针指向类型加const修饰可以防止意外地改动该指针所指向的内容，起到保护作用，对于引用传递同理。**

void StringCopy(char*strDestination, const char *strSource);

其中`strSource`是输入参数，`strDestination`是输出参数。`const char *strSource`加上`const`修饰后，如果函数体内的语句试图改动`strSource`所指向的内容，编译器将指出错误。

如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不需要加const修饰。

对于**非内部数据类型**的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率。例如将`void Func(A a)`改为`void Func(const A &a)`。

对于**内部数据类型**的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如`void Func(int x)`不应该改为`void Func(const int &x)`。

## 用const修饰函数的返回值 ##

如果给以“指针传递”方式的函数返回值加`const`修饰，那么函数返回值（即指针）所指向的内容不能被修改，该返回值只能被赋给加`const`修饰的同类型指针。例如函数

const char * GetString(void);

如下语句将出现编译错误：

char*str = GetString();

正确的用法是

const char *str =GetString();

如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加`const`修饰没有任何价值。

例如不要把函数`int GetInt(void)`写成`const int GetInt(void)`。

同理不要把函数`A GetA(void)`写成`const A GetA(void)`，其中A为用户自定义的数据类型。

函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。  
例如：

classA
    {
        
        A & operate = (const A &other); // 赋值函数
    };
    A a, b, c; // a, b, c 为A的对象
     
    a= b = c; // 正常的链式赋值
    (a= b) = c; // 不正常的链式赋值，但合法

如果将赋值函数的返回值加`const`修饰，那么该返回值的内容不允许被改动。上例中，语句`a= b = c`仍然正确，但是语句`(a= b) = c`则是非法的。

## const 成员函数 ##

任何不会修改数据成员的函数都应该声明为`const`类型。如果在编写`const`成员函数时，不慎修改了数据成员，或者调用了其它非`const`成员函数，编译器将指出错误，这无疑会提高程序的健壮性。

以下程序中，类`stack`的成员函数`GetCount`仅用于计数，从逻辑上讲`GetCount`应当为`const`函数。编译器将指出`GetCount`函数中的错误。

classStack
    {
        
    public:
        void Push(int elem);
        int Pop(void);
        int GetCount(void) const; // const 成员函数
    private:
        int m_num;
        int m_data[100];
    };
     
    int Stack::GetCount(void)  const
    {
        
        ++ m_num; // 编译错误，企图修改数据成员m_num
        Pop();// 编译错误，企图调用非const函数
        returnm_num;
    }

`const` 成员函数的声明看起来怪怪的：`const`关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。  
关于`Const`函数的几点规则：

*  `const`对象只能访问`const`成员函数,而非`const`对象可以访问任意的成员函数,包括const成员函数.
 *  `const`对象的成员是不可修改的,然而`const`对象通过指针维护的对象却是可以修改的.
 *  `const`成员函数不可以修改对象的数据,不管对象是否具有`const`性质.它在编译时,以是否修改成员数据为依据,进行检查.
 *  然而加上`mutable`修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的`const`成员函数是可以修改它的

**补充：const放在后面有什么意思？**  
一个函数 const放在后面跟前面有区别么  
==>  
准确的说const是修饰this指向的对象的  
譬如，我们定义了

classA{
        
    public:
        f(int);
    };

这里`f`函数其实有两个参数，第一个是`A* const this`, 另一个才是`int`类型的参数。如果我们不想`f`函数改变参数的值，可以把函数原型改为`f(const int)`,但如果我们不允许`f`改变`this`指向的对象呢？因为`this`是隐含参数，`const`没法直接修饰它，就加在函数的后面了，表示`this`的类型是`const A *const this`。`const`修饰`*this`是本质，至于说“表示该成员函数不会修改类的数据。否则会编译报错”之类的说法只是一个现象，根源就是因为`*this`是`const`类型的。

# 处理类型 #

## 类型别名 ##

类型别名是某种类型的同义词，它让复杂的类型名字变得简单明了、易于理解和使用，还有助于程序员清楚地知道使用该类型的真实目的。

有两种方法可用于定义类型别名。

传统方法使用的是关键字`typedef`:

typedef double wages;   // wages是double的同义词
    typedef wages base, *p; // base是double的同义词，p是double*的同义词

C++11使用关键字 `using`进行别名声明（alias declaration），作用是把等号左侧的名字规定成等号右侧类型的别名。

using SI = Sales_item; // SI是Sales item的同义词

using的更多用法可参考[C++中using的使用][C_using]

*  在当前文件中引入命名空间
 *  在子类中使用 using 声明引入基类成员名称
 *  别名指定，特别是可以用于模板别名

## auto类型说明符 ##

C++11新增 `auto`类型说明符，能让编译器自动分析表达式所属的类型。`auto` 定义的变量必须有初始值。编译器推断出来的 `auto`类型有时和初始值的类型并不完全一样，编译器会适当地改变结果类型，使其更符合初始化规则。

*  当引用被用作初始值时，真正参与初始化的其实是引用对象的值。编译器以引用对象的类型作为 auto 的类型。

int i = 0, &r = i;
    auto a = r;     // a是一个整数(r是i的别名，而i是一个整数)

*  `auto`一般会忽略顶层 `const`，同时底层 `const` 则会保留下来。如果希望推断出的 `auto`类型是一个顶层 `const`，需要显式指定 `const auto`。

const int ci = i, &cr = ci;
    auto b = ci;    // b是一个整数(ci的顶层const特性被忽略掉了)
    auto c = cr;    // c是一个整数(cr是ci的别名，ci本身是一个顶层const)
    auto d = &i;    // d是一个整型指针(整数的地址就是指向整数的指针)
    auto e = &ci;   // e是一个指向整数常量的指针(对常量对象取地址是一种底层const)
    
    const auto f = ci;  // ci的推演类型是int，f是const int

*  设置类型为 `auto` 的引用时，原来的初始化规则仍然适用，初始值中的顶层常量属性仍然保留。

auto &g = ci;   		// g是一个整型常量引用，绑定到ci
    auto &h = 42;   		// error: 不能为非常量引用绑定字面值
    const auto &j = 42;     // ok: 可以为常量引用绑定字面值

## decltype类型指示符 ##

C++11新增 `decltype` 类型指示符，作用是选择并返回操作数的数据类型，此过程中编译器分析表达式并得到他的类型，却不实际计算表达式的值。

decltype(f()) sum = x;  // sum的类型就是函数f的返回类型

编译器并不实际调用`f()`，而是使用当调用发生时`f()`的返回值类型作为`sum`的类型。

`decltype` 处理顶层 `const` 和引用的方式与 `auto` 有些不同，如果 `decltype` 使用的表达式是一个变量，则 `decltype` 返回该变量的类型（包括顶层 `const`和引用）。

const int ci = 0, &cj = ci;
    decltype(ci) x = 0;     // x的类型是const int
    decltype(cj) y = x;     // y的类型是const int&， y绑定到变量x
    decltype(cj) z;     	// error: z是一个引用，必须初始化

如果 `decltype`使用的表达式不是一个变量，则 `decltype` 返回表达式结果对应的类型。如果表达式的内容是解引用操作，则 `decltype`将得到引用类型。

// decltype的结果可以是引用类型
    int i = 42, *p = &i , &r = i;
    decltype (r + 0) b; // 正确：加法的结果是int，因此b是一个(未初始化的)int
    decltype (*p) c; 	// 错误：c是int&，必须初始化

注意：如果 `decltype` 使用的是一个不加括号的变量，则得到的结果就是该变量的类型；如果给变量加上了一层或多层括号，则 `decltype` 会得到引用类型，因为变量是一种可以作为赋值语句左值的特殊表达式。`decltype((var))`的结果永远是引用，而 `decltype(var)`的结果只有当 `var` 本身是一个引用时才会是引用。

// decltype的表达式如果是加上了括号的变量，结果将是引用
    decltype ((i)) d;  // 错误：d是int&，必须初始化
    decltype (i) e;    // 正确：e是一个(未初始化的)int

# 自定义数据结构 #

类定义的最后应该加上分号。

如果要在不同文件中使用同一个类，类的定义就必须保持一致。为了确保各个文件中类的定义一致，**类通常被定义在头文件中**，而且类所在头文件的名字应与类的名字一样。

头文件通常包含那些只能被定义一次的实体，如类、`const`和`constexpr`变量。

头文件经常用到其他头文件的功能，有必要在书写头文件的时候做适当处理，使其遇到多次包含的情况也能安全和正常的工作。确保头文件多次包含仍能正常工作的常用技术是**预处理器**。在高级版本的IDE环境中，可以直接使用`#pragma once命令`来防止头文件的重复包含。

头文件保护符（header guard）依赖于预处理变量（preprocessor variable）。预处理变量有两种状态：已定义和未定义。`#define`指令把一个名字设定为预处理变量。`#ifdef`指令当且仅当变量已定义时为真，`#ifndef`指令当且仅当变量未定义时为真。一旦检查结果为真，则执行后续操作直至遇到`#endif`指令为止。预处理变量无视C++语言中关于作用域的规则。

#ifndef SALES_DATA_H
    #define SALES_DATA_H
    #include <string>
    struct Sales_data 
    {
        
        std::string bookNo;
        unsigned units_sold = 0;
        double revenue = 0.0;
    };
    #endif

头文件一旦改变，相关的源文件必须重新编译以获取更新过的声明。

# 练习 #

**下列程序的运行结果为？**

unsigned u = 10, u2 = 42;
    std::cout << u2 - u << std::endl;
    std::cout << u - u2 << std::endl;
    
    int i = 10, i2 = 42;
    std::cout << i2 - i << std::endl;
    std::cout << i - i2 << std::endl;
    std::cout << i - u << std::endl;
    std::cout << u - i << std::endl;

![在这里插入图片描述][20200418180452379.png]  
u2-u正常运算。  
u-u2时，直接计算的结果是 -32，但因为是无符号数，所以自动加模（测试环境中int为32位，故加上2^32），结果为4294967262。

带符号数和无符号数混合运算时，编译器先把带符号整数转换为无符号整数，在带符号数为负时会出问题。因此**尽量避免这种混用情况的发生**。

unsigned u = 10, u2 = 42;
        std::cout << u2 - u << std::endl;
        std::cout << u - u2 << std::endl;
    
        int i = 11, i2 = 42;
        std::cout << i2 - i << std::endl;
        std::cout << i - i2 << std::endl;
        std::cout << i - u << std::endl;
        std::cout << u - i << std::endl;

![在这里插入图片描述][20200418181646564.png]  
**-------------------------------------------------------------------------------------------**

**指出下述字面值的数据类型并说明每一组内几种字面值的区别：**

(a) 'a', L'a', "a", L"a"
    (b) 10, 10u, 10L, 10uL, 012, 0xC
    (c) 3.14, 3.14f, 3.14L
    (d) 10, 10u, 10., 10e-2

( a ): 字符字面值，宽字符字面值且类型是 wchar\_t，字符串字面值，宽字符串字面值。  
( b ): 普通的整数类型字面值，无符号数，长整型数，无符号长整型数，八进制数，十六进制数。  
( c ): 普通的浮点类型字面值，float 类型的单精度浮点数，long double 类型的扩展精度浮点数。  
( d ): 整数，无符号整数，浮点数，科学计数法表示的浮点数。

**-------------------------------------------------------------------------------------------**

**下述字面值表示何种含义？它们各自的数据类型是什么？**

(a) "Who goes with F\145rgus?\012"
    (b) 3.14e1L
    (c) 1024f
    (d) 3.14L

( a ) 字符串。`\145`和`\012`均为转义字符，分别表示`e`和换行符。  
( b )科学计数法表示的拓展精度的浮点数  
( c )存在问题，应该改为`1024.f`。表示单精度浮点数。  
( d )long double类型的拓展精度浮点数

**-------------------------------------------------------------------------------------------**  
**指出下面的语句是声明还是定义：**

(a) extern int ix = 1024;
    (b) int iy;
    (c) extern int iz;

声明与定义的关系是：声明使得名字为程序所知，而定义负责创建与名字关联的实体。  
( a ): 定义了变量 `ix`  
( b ): 声明并定义了变量 `iy`  
( c ): 声明了变量`iz`

**-------------------------------------------------------------------------------------------**  
**说明指针和引用的主要区别**

*  第一，指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的声明周期内它可以指向几个不同的对象；引用不是一个对象，无法令引用重新绑定到另外一个对象。
 *  第二，指针无需在定义时赋初值，和其他内置类型一样，在块作用域内定义的指针如果没有被初始化，也将拥有一个不确定的值；引用则必须在定义时赋初值。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70]: /images/20230521/64d4ee4d9f334f7996ffa7ad7d8e5b47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1ODAwMzEx_size_16_color_FFFFFF_t_70 1]: /images/20230521/89e2fc716f154cc3b2d8c56ace784fac.png
[20200417165809468.png]: /images/20230521/ba868f209e044e67b33f1ed3fa9e8928.png
[20200417172205401.png]: /images/20230521/a1f90393dab348c1b93878ec91c7f19f.png
[C_11_ nullptr]: https://blog.csdn.net/qq_25800311/article/details/88670638
[C_using]: https://blog.csdn.net/qq_25800311/article/details/89059146
[20200418180452379.png]: /images/20230521/cf765920a80b4710973e91dd0832c2dc.png
[20200418181646564.png]: /images/20230521/005385d9799d49bc98b81c14a66d431a.png