C++ Primer：常见类型的初始化

左手的ㄟ右手 2023-07-01 06:25 9阅读 0赞

### C++：常见类型的初始化 ###

*  1. 背景
 *  2. 初始化
 *   *  2.1 整型和浮点型初始化
     *  2.2 引用类型初始化
     *  2.3 指针类型初始化
     *  2.4 绑定指针的引用初始化
     *  2.5 数组初始化。
     *  2.6 string初始化。
     *  2.7 vector初始化

--------------------

# 1. 背景 #

<table> 
 <thead> 
  <tr> 
   <th align="center">常见类型</th> 
   <th>包含</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">内置类型</td> 
   <td>整型(布尔型，字符型，整型)、浮点型</td> 
  </tr> 
  <tr> 
   <td align="center">复合类型</td> 
   <td>引用、指针、数组</td> 
  </tr> 
  <tr> 
   <td align="center">标准库类型</td> 
   <td>string、vector</td> 
  </tr> 
 </tbody> 
</table>

# 2. 初始化 #

## 2.1 整型和浮点型初始化 ##

整型和浮点型初始化时会自动进行类型转换。

#include <iostream>
    using namespace std;
    
    int main()
    {
        int i1 = 1;
        const int i2 = 1;
        double d1 = 3.14;
        const double d2 = 3.14;
    
        int x1 = i1; // int <- int
        int x2 = i2; // int <- const int
        int x3 = d1; // int <- double
        int x4 = d2; // int <- double
    
        const int x5 = i1; // const int <- int
        const int x6 = i2; // const int <- const int
        const int x7 = d1; // const int <- const double
        const int x8 = d2; // const int <- const double
    
        return 0;
    }

## 2.2 引用类型初始化 ##

引用的类型必须与其所绑定对象的类型一致。只要表达式结果可以转换成引用的类型，对常量的引用就允许以它作为初始值。若类间存在继承关系，则对基类的引用可以绑定派生类对象。

#include <iostream>
    using namespace std;
    class A
    {
    public:
        int a;
    };
    
    class B : public A
    {
    public:
        int b;
    };
    
    main()
    {
        int i;
        const int ci = 1;
        double d = 3.14;
        const double cd = 3.14;
    
        //引用的类型必须与其所绑定对象的类型一致
        int &x1 = i;  //正确：x1绑定int，i是int
        int &x2 = ci; //错误：类型不匹配，x2绑定int，ci是const int
        int &x3 = d;  //错误：类型不匹配，x3绑定int，d是double
        int &x4 = cd; //错误：类型不匹配，x4绑定int，cd是const double
    
        //引用特例：对常量的引用
        const int &y1 = i;
        const int &y2 = ci;
        const int &y3 = d;    //正确：d是double，可以转换成const int。
        const int &y4 = cd;   //正确，等价于const int temp = cd;const int &y4 = temp;
        const int &y5 = 1;    //正确，等价于const int temp = 1;const int &y5 = temp;
        const int &y6 = 3.14; //正确，等价于const int temp = 3.14;const int &y6 = temp;
    
        A a;
        B b;
        A &a1 = b; //引用特例：对基类的引用
        B &b1 = a; //错误：类型不匹配，b1引用B，a是A
    
        return 0;
    }

## 2.3 指针类型初始化 ##

指针的类型必须与其所指对象的类型一致。指向常量的指针可以指向一个相应的非常量对象。若类间存在继承关系，指向基类的指针可以指向派生类对象。

#include <iostream>
    using namespace std;
    class A
    {
    public:
        int a;
    };
    
    class B : public A
    {
    public:
        int b;
    };
    
    main()
    {
        int i = 1;
        const int ci = 1;
        double d = 3.14;
        const double cd = 3.14;
    
        //指针的类型必须与其所指对象的类型一致
        int *x1 = &i;  //正确：x1指向int，i1是int
        int *x2 = &ci; //错误：类型不匹配，x2指向int，ci是const int
        int *x3 = &d;  //错误：类型不匹配，x3指向int，d是double
        int *x4 = &cd; //错误：类型不匹配，x4指向int，cd是const double
    
        //指向常量的指针可以指向一个相应的非常量对象
        const int *y1 = &i;  //正确：y1指向const int，i1是int（指针特例）
        const int *y2 = &ci; //正确：y2指向const int，ci是const int
        const int *y3 = &d;  //错误：类型不匹配，y3指向const int，d是double
        const int *y4 = &cd; //错误：类型不匹配，y4指向const int，cd是const double
    
        //存在继承关系的类，指向基类的指针可以指向派生类对象
        A a;
        B b;
        A *a1 = &b; //正确：（引用特例）
        B *b1 = &a; //错误：类型不匹配，b1指向B，a是A。
    
        return 0;
    }

## 2.4 绑定指针的引用初始化 ##

先看引用是否是对常量的引用，按上述引用的规则执行。再看绑定的指针是否指向常量，按上述指针的规则执行。

#include <iostream>
    using namespace std;
    class A
    {
    public:
        int a;
    };
    
    class B : public A
    {
    public:
        int b;
    };
    
    main()
    {
        int i, *pi;
        const int ci = 1, *pci;
        double d = 3.14, *pd;
        const double cd = 3.14, *pcd;
    
        //指针是变量，故引用是对变量的引用，类型需严格匹配。
        //-----------------------------------------------------------------------------------------------
        int *&x1 = &i;  //错误：引用只能绑定对象（左值），不能绑定字面值或表达式计算结果（右值）
        int *&x1 = pi;  //正确：           x2绑定int*，pci是int*
        int *&x2 = pci; //错误：类型不匹配，x2绑定int*，pci是const int*
        int *&x3 = pd;  //错误：类型不匹配，x3绑定int*，pd是double*
        int *&x4 = pcd; //错误：类型不匹配，x4绑定int*，pcd是const double*
    
        //指针是变量，故引用是对变量的引用，类型需严格匹配。
        //-----------------------------------------------------------------------------------------------
        const int *&y1 = pi;  //错误：类型不匹配，y1绑定const int*，pi是int*
        const int *&y2 = pci; //正确：           y2绑定const int*，pci是const int*
        const int *&y3 = pd;  //错误：类型不匹配，y3绑定const int*，pd是double*
        const int *&y4 = pcd; //错误：类型不匹配，y4绑定const int*，pcd是const double*
    
        //指针本身是常量，故引用是对常量的引用。指针指向变量，类型需严格匹配。
        //-----------------------------------------------------------------------------------------------
        int *const &m1 = pi;  //正确：           指针指向int，pi指向int
        int *const &m2 = pci; //错误：类型不匹配，指针指向int，pci指向const int
        int *const &m3 = pd;  //错误：类型不匹配，指针指向int，pd指向double
        int *const &m4 = pcd; //错误：类型不匹配，指针指向int，pcd指向const double
    
        //指针本身是常量，故引用是对常量的引用。指针指向常量，允许指向常量的指针指向一个对应的非常量。
        //-----------------------------------------------------------------------------------------------
        const int *const &n1 = pi;  //正确：           指针指向const int，pi指向int（指向常量的指针可以指向一个对应的非常量）
        const int *const &n2 = pci; //正确：           指针指向const int，pci指向const int
        const int *const &n3 = pd;  //错误：类型不匹配，指针指向const int，pd指向double
        const int *const &n4 = pcd; //错误：类型不匹配，指针指向const int，pcd指向const double
    
        return 0;
    }

## 2.5 数组初始化。 ##

数组一般用花括号初始化，数组间不能初始化、赋值和拷贝。

#include <iostream>
    using namespace std;
    
    main()
    {
        int i = 1;
        const int ci = 1;
    
        int x1[3];
        int x2[3] = {1, 2, 3};
        int x3[3] = {1, 3.14, ci};
        const int x4[3] = {1, 3.14, ci};
    
        //不能用一个数组初始化另一数组
        // int i4 = i1;
    
        return 0;
    }

## 2.6 string初始化。 ##

#include <iostream>
    #include <string>;
    using namespace std;
    
    int main()
    {
        string s1;
        string s2(s1);
        string s3("abc");
        string s4(3, 'a');//s4=aaa
        string s5{"abc"};
    
        string s6 = s1;
        string s7 = "abc";
        string s8 = 'a' + s1;//s8=a
        // string s9 = 'a' + 'b' + s1;//错误：加号两边至少有一边是string类型
        return 0;
    }

## 2.7 vector初始化 ##

#include <iostream>
    #include <vector>;
    using namespace std;
    
    int main()
    {
        vector<string> vi1;
        vector<string> vi2(vi1);
        vector<string> vi3(3);        //vi3包含3个元素
        vector<string> vi4(3, "a");   //vi4包含3个元素，每个元素的初值为a
        vector<string> vi5{"a", "b"}; //vi5包含2个元素，初值分别是a和b
    
        vector<string> vi6 = vi1;
        vector<string> vi7 = {"abc"};
        return 0;
    }