【C++学习】——（四）类型

开篇

​ 类型一直是C++中最重要的部分，相比于其他高级语言，C++的类型会复杂许多，往往一个类型匹配错误就会导致程序报错，本篇主要讲解一些常用类型的概念以及细节，如果对于C++有一定基础的，可以跳转到思考部分，从中了解自己的掌握程度；

初始化与赋值

定义：初始化与赋值语句是程序中最基本的语句，功能是将某个值与一个对象关联起来；

• 值：字面量、对象（变量或常量）所表示的值等
• 标识符（对象）：变量、常量、引用

初始化的基本操作：

1、在内存中开辟空间、保存相应的数值；

2、在编译器中构造符号表、将标识符与相关内存空间关联起来；

类型概述

下面通过几点概要说明：

1、类型是编译期概念，可执行程序中不存在类型的概念；

2、C++是强类型语言；

• 强类型语言定义：一旦一个变量被定义类型，如果不经过强制转换，那么它永远就是该数据类型；

• 弱类型语言定义：某一变量被定义类型，该变量可根据环境变化自动进行转换，不需要强转；

3、引入类型是为了更好描述程序，防止误用；

4、类型描述的信息：

• 存储所需要的大小（sizeof，标准没有严格限制，根据硬件不同字节数也不同）
• 取值空间（可用std::numeric_limits来判断，超过范围可能产生溢出）

#include
#include 

int main() {
    int x = 10;

    std::cout << std::numeric_limits::min() << std::endl;				//-2147483648
    std::cout << std::numeric_limits::max() << std::endl;				//2147483647

    std::cout << std::numeric_limits::min() << std::endl;		//0
    std::cout << std::numeric_limits::max() << std::endl;		//4294967295
}

由上面程序运行结果可知，无符号int类型占4个字节，也就是32个比特位，所以最大范围为2³²，在不同的硬件下可能不同；

• 对齐信息（一般存放在内存中按类型的对齐信息的整数倍存储，比如int的对齐信息为4个字节，那存储的空间首地址为4的倍数，在结构体中，因为存在对齐信息，char也会按4个字节保存）
• 类型可执行的操作

类型分类

类型可以划分为基本类型和复杂类型；

基本（内建）类型：C++语言中支持的类型，包含以下几种：

1、数值类型

• 字符类型：char、wchar_t、char16_t、char32_t，通常为1个字节，表示256个值，也就是ASCII编码的字符；
• 整数类型：带符号整数类型（short、int、long、long long），无符号整数类型（unsigned+带符号整数类型）
• 浮点类型：float、double、long double

注意：在C++11中引入了固定尺寸的整数类型，如int32_t等，之前在针对开发板的程序中有见过该类型，主要是便于硬件的可移植性：

2、void类型

复杂类型：由基本类型组合、变种所产生的类型，可能是标准库引入，或自定义类型；

字面值及其类型

字面值：在程序中直接表示为一个具体数值或字符串的值；

每个字面值都有其类型，例子如下：

• 整数字面值（int）：20（十进制）、024（八进制）、0x14（十六进制）
• 浮点数（double）：1.3、1e8
• 字符字面值（char）：‘c’、’\n’
• 字符串字面值（char[4]）：“cpp”，注意这里字符串后会默认加/0，所以是四个字符长度
• 布尔字面值（bool）：True、False

像如果想要定义float类型的数，可以加入后缀如1.3f；

C++提供了用户创建自定义后缀的函数：

#include

// 后缀可自行定义，我这里用_bang
int operator "" _bang(long double x)
{
    return (int)x * 2;
}

int main() {
    int x = 7.14_bang;
    std::cout << x << std::endl;
}

上面代码将7.14的浮点类型转换成整型并增大一倍，可自行定义后缀试一下；

变量及其类型

变量：对应一段存储空间，可以改变其中内容；

声明与定义的区别：不能重定义已经初始化的变量，需要加入extern用来声明；

初始化：全局变量会默认初始化为0，局部变量会缺省初始化（随机数值）；

复合类型

1、指针：一种间接类型；

如上图为一个指针p指向一段内存，p保存的为val的地址，我们通过打印尺寸可知，指针p为8个字节；

特点：

• 可以"指向"不同的对象；
• 具有相同的尺寸；
• 指针与bool的隐式转换：非空指针可以转换为true、空指针可以转换为false；

注意两个符号：*（解引用符）、&（取地址符）；

解引用符在不同环境下含义不同，看如下代码：

int x = 10;
int* p = &x;		// 表示p为一个int指针类型
*p;				   // 表示解引用，获取指针指向地址的值

关于nullptr：

• 一个特殊的对象（类型为nullptr_t），表示空指针；
• 类似于C中的NULL，但更加安全；

void 指针*：没有记录对象的尺寸，可以表示任意类型指针，一般作为形参或返回值；

指针对比对象：指针复制成本低，引用成本高；

总结：指针在程序中的作用，最重要的就是作为参数传入，由于数据类型可能很大，传入指针大小固定为8个字节，并且指针值为地址可复制，复制成本低，并且可在函数中改变变量的值；

2、引用：

取地址符&也有两个含义：

int x = 10;
&x;						// 取地址符
int& ret = x;			 // 定义ret为一个引用类型

特点：

• 是对象的别名，不能绑定字面值（指针也不能指向字面值）；
• 构造时绑定对象，在其生命周期内不能绑定其他对象（赋值操作会改变对象内容）；
• 不存在空引用，但可能存在非法引用，总体比指针安全；
• 属于编译期概念，在底层还是通过指针实现；

常量类型

• 使用关键字const声明常量对象；
• 是编译期概念，由编译器保证，作用为防止非法操作、优化程序逻辑；

常量指针（顶层常量）：

int* const p = &x;

常量指针表示指针为常量，指针不能更改指向；

底层常量：

const int* p = &x;

底层常量表示指针指向的地址的内容不能发生改变，指针指向可改变；

常量引用：

• 用const int&定义一个常量引用；
• 主要用于函数形参（对于较复杂的数据类型）；
• 可以绑定字面值；

常量表达式：

constexpr int x = 1;		// x的类型仍为const int

• 声明的是编译期的常量，编译器可以对其进行优化；

类型别名

类型别名：引入特殊的含义或便于使用，例如size_t；

• 引入类型别名的两种方式：

  1、typedef int Mytype；

  2、using Mytype = int；（C++11后）

  第二种方式更好；

• 应将指针类型别名视为一个整体，引入常量const表示指针为常量的类型；

• 不能通过类型别名构造引用的引用；

类型自动推导

定义：通过初始化表达式定义对象类型，编译器会自动推导得到；（C++11开始）

• 推导得到的类型还是强类型，并不是弱类型；

• 自动推导的几种形式：

  1、auto：最常用的形式，会产生类型退化（由于左值右值的类型区别）；

  2、const auto、constexpr auto：推导出的是常量、常量表达式类型；

  3、auto&：推导出引用类型，避免类型退化；

  4、decltype(exp)：返回exp表达式的类型（左值加引用）；

  5、decltype(val)：返回val的类型；

  6、decltype(auto)：简化decltype的使用，C++14开始支持；

  补充：类型退化表示一个变量作为左值和右值时类型不同，例如数组作为右值为指针；

域与对象声明周期

域（scope）：表示程序中的一部分，其中的名称有唯一含义，有全局域、块域等；

• 域可以嵌套，嵌套域中定义的名称可以隐藏外部域中定义的名称；
• 对象的生命周期起始于被初始的时刻，终止于被销毁的时刻；
• 全局对象的生命周期是整个程序运行期间，局部对象终止在所在域执行完成；

思考

1、思考下下面关于指针的两行代码的含义：

int x = 1;
int* p = &x;
int y = 0;
*p = y;				// 第一行
p = &y;				// 第二行

这两行表明了指针的一个特定，可改变性，每一行的含义如下：

第一行：将指针p指向的内存地址的值改变为y；

第二行：不改变x的值，而是将指针p的指向改成y；

2、经过指针的思考后，我们看看关于引用的思考：

int x = 1;
int& f = x;
int y = 0;
f = y;				// 思考一下这一行的作用，是改变了引用f的绑定吗？ 

上面这行代码并不改变f的绑定，而是改变了f的值，同时引用对象x的值也发生改变；

3、经过了指针和引用的思考，下面思考下两者在底层有什么关联：

int x;
int* p = &x; *p = 1;
int& f = x; f = 1;

分析下上面两行代码，他们底层实现会相同吗？

这是两者的汇编代码实现，可以发现是完全相同的，引用底层也是通过指针实现的；

4、思考以下代码中&x是什么数据类型？

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

如果我们只考虑&x的话，这是一个int*的类型，但由于第二行代码执行拷贝构造，隐式地将&x转换为左值所需要的 const int *类型；

5、思考下面函数传参的区别？

void fun(int x){}
void fun(const int& x){}

从本质上来说，上面两种传参实现的作用是一致的，第一个进行拷贝构造传递，所以在函数内部无法改变外部x变量的值，而下面的传参传入引用可以在函数内部改变外部x的值，加入const强制成变量；第二种其实是画蛇添足地做法，但常量引用对于复杂的数据类型来说，是能够节省很多空间的，比如自定义的结构体；

6、下面常量表示底层常量还是顶层常量？

using mytype = int*;
int x = 1;
const mytype p = &x;

这里我们容易误导，还会认为这是一个底层常量，但由于别名的定义，这里其实是一个顶层常量，我们可以将mytype看作一个整体，那么指针的指向不可发生改变；

7、下面auto&自动推导出的y是什么类型？

const int x = 1;
auto& y = x;

相信大部分人会认为x会类型退化，从而y为int&类型，实际上这里类型不会退化，所以y为const int&类型；

8、下面来看看decltype自动推导的类型是什么？

int x = 1;
decltype(x);		// 1 
decltype((x));		// 2

decltype在传入参数为左值时加入引用，那么第一行为一个变量，所以为int类型，第二行为表达式，所以加入引用为int&类型；

总结

​ 本篇讲解的类型知识点很杂，并且涵盖很多小的知识点，很多细节部分在实际工程中不一定会接触到，当然在工程中也会遇到很多自己不理解的类型转换，需要多通过debug模式来查看类型；

​ 本篇知识点较多，可以选择自己想了解的部分进行查看，后续会继续推出更深层次的内容；