能否在类的析构函数中调用delete this?#

不能

实验告诉我们，会导致堆栈溢出。原因很简单，delete的本质是“为将被释放的内存调用一个或多个析构函数，然后，释放内存显然，delete this会去调用本对象的析构函数，而析构函数中又调用delete this，形成无限递归，造成堆栈溢出，系统崩溃。

能否在类的其它函数中调用delete this？#

可以，但不可以涉及到任何和this指针（成员变量，成员函数，虚函数）相关的东西。一旦涉及到this指针，如操作数据成员，调用虚函数等，就会出现不可预期的问题。

首先，让我们明确几点概念

• 在类对象的内存空间中，只有数据成员和虚表指针，并不包含代码内容。类的成员函数单独放在代码段中

• 在调用成员函数时，隐含传递一个this指针，让成员函数知道当前是哪个对象在调用它。当 调用delete this时，类对象的内存空间被释放。在delete this之后进行的其他任何函数调用，只要不涉及到this指针的内容，都能够正常运行。一旦涉及到this指针，如操作数据成员，调用虚函数等，就会出现不可预期的问题。

• delete this释放了类对象的内存空间，但是内存空间却并不是马上被回收到系统中，导致这段内存空间暂时并没有被系统收回。此时这段内存是可以访问的。这时访问数据成员可能是随机数，访问虚表发生指针无效的概率很高，系统崩溃。

什么时候可以？#

this指向的实例必须是new出来的，不能是new[] /placement new出来的，也不能是栈上的，也不是全局变量。只能是简单的new出来的。

调用了delete this 的成员函数（下面称为当事函数）返回后，这个实例不可以调用其他任何成员函数（这好理解，涉及到this指针，因为实例不存在了）。这个成员函数应当成为这个实例访问的最后一个函数。

调用了delete this 的成员函数后（从delete this这一行之后开始），这个实例不可以调用任何成员函数和成员变量（这好理解，理由同2）

调用了delete this之后，不得以任何形式提及this，包括比较、打印、类型转换等（因为this已经不存在了）。

换言之，为什么一个指向类成员的指针被delete并置空后依旧可以调用不访问类成员数据的函数？或者是为什么一个类类型的空指针可以访问类内非虚且不访问成员变量的函数？#

1
class myclass{
2
    public:
3
        void print(){
4
            cout <<"myclass" << endl;
5
        }
6

7
        int vala = 10;//类成员没有被print函数访问。
8

9
};
10
int main(){
11
    myclass* ptr = new myclass();
12
    ptr->print(); //输出myclass
13
    delete ptr;
14
    ptr = nullptr;
15
    ptr->print(); //输出myclass
16
    return 0;
17
}

我们看到delete后依旧可以调用没有访问类成员的函数。另一个前提是该函数不是虚函数。因为虚函数的调用需要依靠对象的虚函数指针找虚函数表。调用delete资源释放后置空导致和this有关联了。所以报错。

**非虚的类成员函数在编译的时候就已经解决了访问问题。也就是编译成带作用域的全局函数。并添加this形参。**也就是访问非虚而且不访问类成员(变量)的函数是不涉及到this指针的。虽然指针必须要被传入，但是传入参数并不关心当前指针是否有效。只要没有解引用this指针即可。

我们再思考一下。如果上面的例子换成C写是什么样子的？

1
struct myclass_inC{
2
    int vala = 10;
3
};
4

5
void print(myclass_inC* self){
6
    cout <<"myclass" << endl;
7
}
8

9

10
int main(){
11
    struct myclass_inC *myclass_c = NULL;
12
    print(myclass_c); //输出my_class
13
    return 0;
14
}

在深度探索C++对象模型的笔记4.1我们提到：

因为编译器会把每所有的非虚函数（此处不确定是否正确。有的笔记里写的是普通函数，普通成员函数和静态成员函数。书里此处没有提及静态成员函数。）进行处理：

1. 首先是把对象调用的方式改为值调用。也就是在形参的第一个位置放一个this指针（指向对象的指针）做为入参

2. 其次是把函数内对于非静态数据成员的直接操作变成用this指针的操作。

3. 然后是名称重新编译成独特名称（这一步的目的是实现重载。注意，C++重载是依靠名称和参数，C只有名称）

4. 最后是实施NRV优化（如果有）

类成员函数在处理后可以理解为变成了带作用域的全局函数。虚函数也只不过是多了查表的步骤。

我们上面用C写的例子和处理后的非虚类成员函数差不多。此时我们可以看到。尽管我们的类指针是空的。但是它依旧符合函数入参类型。而且我们在函数内并没有通过这个指针访问任何数据成员。所以并不会报错。单纯传递空指针是可以的。所以是可以调用这样的成员函数的。

为什么如果析构函数不是虚函数的时候，仅仅执行父类析构函数？#

很多人可能会有疑问，问我们知道构造顺序是先父类构造再子类构造，析构顺序是先子类析构再父类析构（仅多态情况）。那么为什么我父类析构不是虚析构的时候仅执行父类析构？难道不应该是仅执行子类析构吗？

因为忘了一点，多态调用必须是虚函数才可以，仅通过父类指针指向子类对象是不会触发虚机制（动态绑定（多态））的。

虽然父类指针可以指向子类，但是其访问范围还是仅仅局限于父类本身有的数据，那些子类的数据，父类指针是无法访问的。

1
class A{
2
    public:
3
    A(){}
4

5
};
6

7
class B: public A{
8
    public:
9
    B(){}
10
    int bval = 3;
11
};
12

13
class C :public B{
14
    public:
15
    C(){}
16
    int cval = 4;
17
};
18

19
int main(){
20
    A* a = new C;
21
    cout << a->bval << endl; //错误。类A没有成员bval
22
}

运算符重载可以继续被重载。符合函数重载规则即可。#

类模板的运算符重载 在 模板笔记内#

运算符重载#

1
class multiple{
2
    public:
3
    int vala;
4
    int valb;
5
    multiple(){}
6
    multiple(int x, int y):vala(x), valb(y){}
7
    const multiple operator*(const multiple& rhs) const{
8
        multiple temp(this->vala * rhs.vala, this->valb*rhs.valb);
9
        return temp;
10
    }
11
    注意 乘法我们说是有两个参数即a*b 但是这里现在是成员函数，第一个参数默认是调用对象 即this 所以形参只有一个rhs。
12
    但是我们可以写为非成员函数，这样形参就会有rhs和lhs。
13
    非成员函数在进行隐式类型转换的时候可以实现交换律。参考effectiveC++ 条款24
14
    void getval(){
15
        cout << this->vala<< ", " << this->valb << endl;
16
    }
17

18
};
19

20
const multiple operator*(const multiple& lhs, const multiple& rhs){
21
    multiple temp(lhs.vala * rhs.vala, lhs.valb*rhs.valb);
22
    return temp;
23
}
24

25
//类外可以这么写。注意const不可修饰非成员函数！！
26
int main()
27
{
28
    multiple t1(5,5);
29
    multiple t2(6,4);
30
    multiple t3 = t1 * t2;
31
    t3.getval();
32
这里t3 = t1 * t2本质上是t3 = t1.operator*(t2)
33
t1是this，t2是rhs，t1.operator*(t2)对应函数返回值
34
}

注意 这里重载第三个const的目的是让这个函数成为const函数。目的是可以被const对象调用 这里的例子就是我们避免意外赋值，使重载返回值也是const 因为如果不设置const的话 像是

1
(t1 * t2) = t3;

这种就不会报错。因为t1*t2被当成了一个multiple类型的变量。可以给它赋值。因为它返回一个multiple对象。但是这违背了我们的意愿。所以我们加const来模拟常量确保t1*t2不会被赋值 如果我们这个重载函数不设置const属性（也就是第三个const）的话，我们这样就无法链式调用了。因为我们现在的t1*t2返回的是一个const multiple对象。const对象无法调用非const函数。所以我们的函数必须要const

• 当运算符重载为类的成员函数时，函数的参数个数比原来的操作数要少一个（后置单目运算符除外），这是因为成员函数用this指针隐式地访问了类的一个对象，它充当了运算符函数最左边的操作数。因此：

  • 双目运算符重载为类的成员函数时，函数只显式说明一个参数，该形参是运算符的右操作数。

  • 前置单目运算符重载为类的成员函数时，不需要显式说明参数，即函数没有形参。

  • 后置单目运算符重载为类的成员函数时，函数要带有一个整型形参。

  • 调用成员函数运算符的格式如下：

    1
    <对象名>.operator <运算符>(<参数>)
    2
    它等价于
    3
    <对象名><运算符><参数>
    

• 当运算符重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所有的操作数都必须通过函数的形参进行传递，函数的参数与操作数自左至右一一对应。调用友元函数运算符的格式如下：

  1
  operator<运算符>(<参数1>,<参数2>)
  2
  它等价于
  3
  <参数1><运算符><参数2>
  

  • 友元函数不属于任何类，但是可以当做类成员函数使用，即访问私有部分。友元函数必须在类内声明。但是可以在类内或类外定义

  1
  class multiple{
  2
      public:
  3
      multiple(){}
  4
      multiple(int x, int y):vala(x), valb(y){}
  5
      friend const multiple operator*(const multiple& lhs, const multiple& rhs); //类内声明
  6
      void getval(){
  7
          cout << this->vala<< ", " << this->valb << endl;
  8
      }
  9
      private:
  10
      int vala;
  11
      int valb;
  12
  
  13
  };
  14
  const multiple operator*(const multiple& lhs, const multiple& rhs){ //类内或类外定义均可。
  15
      multiple temp(lhs.vala * rhs.vala, lhs.valb*rhs.valb);
  16
      return temp;
  17
  }
  18
  int main()
  19
  {
  20
      multiple t1(5,5);
  21
      multiple t2(6,4);
  22
      multiple t3 = t1 * t2;
  23
      t3.getval();
  24
  }
  

• 在类外，因为不是成员函数所以没有this指针，所以必须要有全部参数。

• 运算符重载写为友元的核心目的是解决两个不同的类的数据访问问题。

  • 比如A和B想要做A+B的时候。因为A不能访问B的私有成员。所以可以把这个A.operator+(const B&)写进B并且声明为friend。

1
class myclass{
2
    public:
3
    int val1;
4
    int val2;
5
    myclass(){}
6
    myclass(int x, int y):val1(x), val2(y){}
7
    bool operator()(const myclass& a, const myclass& b){
8
        cout <<"comp" <<endl;
9
        return a.val1 < b.val1;
10
    }
11

12
};
13

14
class mycomp{            //这么写是错的。这里的运算符重载被当做了mycomp的运算符重载
15
    public:
16
    bool operator<(const myclass& a, const myclass& b){
17
        cout <<"comp11" <<endl;
18
        return a.val1 < b.val1;
19
    }
20
};
21
bool operator<(const myclass& a, const myclass& b){
22
        cout <<"comp11" <<endl;
23
        return a.val1 < b.val1;
24
    }
25

26

27
int main()
28
{
29
    set<myclass> myset;          //如果重载的是小于号，则写在类内类外都不需要在模板处指定排序类型。
30
    set<myclass, myclass> myset1;    //如果重载的是括号也就是调用运算符，则无论写在类内类外都需要在模板处指定排序类型。
31
    myset.insert(myclass(5,10));
32
    myset.insert(myclass(1,10));
33
    myset.insert(myclass(10,10));
34
  return 0;
35
}

1
class myclass{
2
    public:
3
    int val1;
4
    int val2;
5
    myclass(){}
6
    myclass(int x, int y):val1(x), val2(y){}
7
    bool operator()(const myclass& a, const myclass& b) const {
8
        cout <<"comp" <<endl;
9
        return a.val1 < b.val1;
10
    }
11
    bool operator()(const myclass* a, const myclass* b){
12
        cout <<"comp112" <<endl;
13
        return a->val1 < b->val1;
14
    }
15

16
};
17

18

19
class mycomp{
20
    public:
21
    bool operator()(const myclass* a, const myclass* b){    //写在类外
22
        cout <<"comp11" <<endl;
23
        return a->val1 < b->val1;
24
    }
25
};
26
int main()
27
{
28
    set<myclass*, myclass> myset;        //指针容器，必须使用重载函数调用运算符的方式，并且指定其类型。可以写在类外
29
    set<myclass*, mycomp> myset;        //也可以
30
    myset.insert(new myclass(5,10));
31
    myset.insert(new myclass(1,10));
32
    myset.insert(new myclass(10,10));
33
  return 0;
34
}

成员访问运算符 -> 重载#

类成员访问运算符（ -> ）可以被重载，它被定义用于为一个类赋予”指针”行为。运算符 -> 必须是一个成员函数。如果使用了 -> 运算符，返回类型必须是指针或者是类的对象。

1
class obj{
2
    public:
3
    int val;
4
    obj(int x):val(x){};
5

6
    void objfunc(){
7
        cout <<"obj" << endl;
8
    }
9
    void getval(){
10
        cout << val << endl;
11
    }
12
};
13
class objhelper{
14
    public:
15
    objhelper(){
16
        objptr = new obj(10); //构造函数初始化另一个类的对象
17
    }
18
    obj* operator->(){ //注意，返回的是obj类的指针。
19
        return objptr;
20
    }
21

22
    ~objhelper(){
23
        delete objptr; //析构函数释放对象。
24
    }
25
    obj* objptr; //类内持有一个另一个类的指针。
26

27

28
};
29
int main(){
30

31
    objhelper helper;
32
    helper->objfunc(); //输出obj
33
    helper->getval();  //输出10
34

35
    return 0;
36
}

从上面代码我们可以看到，重载类成员访问运算符多半是起到一个帮助作用，帮助我们访问另一个类。

重载成员访问运算符根据调用者的类型不同，有两条作用规则：

1. 如果调用者是指针，则按照内置的箭头运算符去处理。表达式等价于(*调用者).member。首先解引用该指针，然后从所得的对象中获取指定的成员。如果调用者所指的类没有名为member的成员，则编译器报错。
2. 如果调用者是一个定义了operator->() 的类对象，则调用者->member等价于调用者.operator->() ->member。其中，如果operator->()的返回结果是一个指针，则转第1步；如果返回结果仍然是一个对象，且该对象本身也重载了operator->()，则重复调用第2步，否则编译器报错。最终，过程要么结束在第一步，要么无限递归，要么报错。 https://blog.csdn.net/friendbkf/article/details/45949661

——来自Modern C++ Design 7.3 P.160

解引用运算符*重载#

*是一个一元操作符，作用于指针，获取指针所指单元的内容。当某个类中对*操作符重载时，是将该类对象当做一个指针看待，用*操作符提取指针所指向的内容。它一般有两个版本。一个是普通成员函数返回某个类中的指针的解引用的引用，也就是指针指向的对象的引用。另一个版本是常量成员函数返回const引用。（再次强调返回值不是函数签名。但是修饰成员函数的const是函数签名）

• 为什么要返回引用？如果不返回引用则无法给解引用的对象赋值。比如*ptr = 200
  • 不返回引用的话，解引用返回的是一个临时对象，是右值。无法给右值赋值。

1
//在上面的代码中添加：
2
obj& operator*(){ //返回的是引用！！
3
    return *objptr; //返回类内指针的解引用
4
}
5

6
const obj& operator*() const{
7
    return *objptr;
8
}

取址运算符&重载#

罕有使用。参考模板笔记的std::address_of部分和more effective c++的条款30。

解答：#

1. 在类内，如果是双目运算符就少一个。因为左手部分是this。隐式传递。如果是类外，就正常两个。
2. 不在类里面声明，可以正常访问类公有部分。如果需要访问私有部分就需要使用友元函数。

关于为什么赋值运算符必须有返回值并且一般都返回引用#

比如在移动赋值或者拷贝赋值中返回的都是引用。

原因主要是性能和为了链式调用。

• 链式调用：

1
a = b = c;
2
//就是先执行b=c然后执行a = b。等价于
3
a.operator=(b.operator=(c))

此时若不返回左值的引用，将会生成临时对象，

因为不能修改标准库，所以重载流插入<<和流提取>>的时候如果在类内则必须用友元的方式。要么就是全局#

为什么有时候运算符重载要在类外也写一份？#

我们来看下面这个例子

1
class myInt{
2
    public:
3
    int val1;
4
    myInt(){}
5
    myInt(int x):val1(x){} //这里没有explicit
6

7
    const myInt operator+(const myInt& rhs){
8
        return myInt(this->val1 + rhs.val1);
9
    }
10

11
};
12

13
const myInt operator+(const myInt& lhs, const myInt& rhs){ //这里类外要有一份
14
    return myInt(lhs.val1 + rhs.val1);
15
}
16

17

18
int main()
19
{
20
    myInt a(10);
21
    myInt b(20);
22

23
    myInt c = a + b;
24

25
    myInt d = a + 10; //这个等于 myInt d = a + myInt(10); 因为有转换构造所以可以。
26

27
    myInt e = 10 + a; //这等于 myInt e = myInt(10) + a; 如果不写类外，这个不行。
28
    cout << c.val1 << endl;
29
    cout << d.val1 << endl;
30
  return 0;
31
}

• 我们这里有隐式类型转换。因为有单参的转换构造函数。所以如果构造函数用explicit修饰了就不行了，就要显式调用构造函数生成临时对象了。
• 其次，如果不写类外实现，如10+a这样的就不能调用。因为a+10是a.operator+(10)，但是没有10.operator+(a)。所以这时候就需要有一个全局的接受两个参数的operator+。这两个可以并存。所以现在是operator+(10, a)。是可以的。
• 所以一般来说，当前面的调用者是基本类型的时候，就需要写一个全局的操作符重载。

千万不要重载 ||, && 和 ,#

因为他们的表现方式和内建版本不同。

• 布尔逻辑运算符的重载版本无法实现短路求值，并且不会令左侧操作数的求值按照顺序早于右侧操作数。
• 逗号运算符的重载版本不会令左侧操作数的求值按照顺序早于右侧操作数。

关于逗号运算符这里有一个非常特殊的点。在文档中提到了：

因为此运算符可能被重载，所以泛型库都用 a,void(),b 这种表达式取代 a,b

在stackoverflow也有同样的疑惑，为什么要这么做？

我们拆开看。在a有自己的逗号运算符的时候，a,void()会变成a.operator,(void())。但是因为void()表达式会返回一个void类型, 但是void不是有效类型(不完整类型)，所以a无论是任何类型都不可能有一个自己的逗号运算符重载的操作数类型是void。同时重载operator,必须提供一个参数(右操作数)。 所以这里一定会用到内置的版本。在运算完后，结果会变成void，因为第一个表达式的运算结果在求值后会被丢弃，只会保留第二个的结果。现在是void,b了。左侧void必然只会用内置类型的逗号表达式。所以这样做是有效的。

剩下的请参照杂记4的序列点部分和more effective c++ 条款7

运算符重载的语义，个人感悟#

运算符重载就是函数调用，一定要思考语义。

首先关于函数内部要做什么，要不要修改左侧操作数？

用加法举例子，如果你想要达到执行a+500能直接把a的数也改变，那么可以直接在加法重载内改变a的值。如果你不允许链式调用，则没必要有返回值。这完全合法。

包括拷贝赋值运算符也不是强制返回T&的。如果你不想链式调用，完全可以写成这样

1
struct myclass{
2
    int val = 0;
3
    myclass(int x):val(x){};
4
    myclass operator+(const myclass& rhs){
5
            return myclass(val + rhs.val);
6
    }
7
    void operator=(const myclass& rhs){
8
        val = rhs.val;
9
        cout <<"copy assignment" << endl;
10
    }
11
};
12
int main(){
13
    myclass obj(200);
14
    myclass obj2(300);
15
    cout << obj2.val << endl;
16
    obj2 = obj;
17
    cout << obj2.val << endl;
18
}

a.operator=(b)压根不是返回值作用于a。是先修改了a然后同时返回自己而已。目的就是链式调用。所以a = b这个表达式，返回值压根就没用上。

所以核心就是要思考某个特定的运算符重载是否符合直观性的语义。也就是一般性的使用方式。

可以参考这个：https://stackoverflow.com/questions/4421706/what-are-the-basic-rules-and-idioms-for-operator-overloading

强制类型转换可以进行引用类型的转换#

其实就是通过原对象生成一个原对象的引用。这个操作合法。

例子：

1
float ss = 10.12345;
2
float& dd = static_cast<float&>(ss); //生成一个ss的引用。也就是通过ss生成一个新的float&类型的对象。
3
cout << dd <<endl; //10.1235
4
dd = 9.324;
5
cout << dd << endl; //9.324
6
cout << ss << endl; //9.324

static_cast#

1
static_cast <type-id> (expression)

将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：

1. 用于类层次结构中，父类和子类之间指针和引用的转换；
   • 当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
   • 当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；
2. 用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；
   • static_cast可以转换对象。
     • 转换对象的前提是：
       • 基础类型之间：提到过比如int换成char
       • **有继承关系之间的对象。且由于是对象，只能进行上行转换。也就是子类对象转为父类对象。父类对象转为子类对象不可能的。**因为只能往小切，不能往大扩。多出来的内存空间不知道用来作什么。
       • 可被转换（如拥有转换(构造)函数）的对象
3. 把void指针转换成目标类型的指针，是及其不安全的；
4. 将一个左值转换为右值引用，这是允许的。（std::move的实现)。对于操作右值引用的代码来说，将一个右值引用绑定到一个左值的特性允许它们截断左值。有时候这种截断是安全的

• static_cast不能移除掉表达式的const、volatile和__unaligned属性。但是可以添加。

dynamic_cast#

1
dynamic_cast <type-id> (expression)

将expression转换为type-id类型

• dynamic_cast转换仅适用于指针或引用。

• *type-id必须是类的指针、类的引用或者是void ；如果type-id是指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用。

• 必须满足多态条件（有虚函数，因为依赖RTTI）

• 不能移除CV限定。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；**在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。在多态类型之间的转换主要使用dynamic_cast，因为类型提供了运行时信息。**就像我在虚表那一章节说的。虚表头还有一块东西就是RTTI，表明了当前类的类型信息。

一般来说，dynamic_cast 用于下行转换的时候，只能用于有虚函数表的类。因为dynamic_cast依赖于RTTI的type_info，然而这个信息储存在虚函数表的头部。

这个dynamic_cast是怎么用的呢？我们父类指针指向子类对象的时候，限制了指针仅可以读取子类对象的父类部分。我们进行dynamic_cast的时候，会使用RTTI信息。这个信息是储存在虚函数表的头部。也就是编译器找到了虚函数表指针（子类对象的虚函数表指针一定指向自己的虚函数表，所以RTTI信息类型也是子类），然后问RTTI：”这人想要让我转换成子类，也就是多读点儿子类的东西，你帮我看看我指向的对象到底是不是子类，多读的那部分被正确初始化了没有？合法不合法？“。RTTI看了一眼回答：”哦，你指向的部分实际类型确实是一个子类的类型，因为他new的时候new的是一个子类对象。我检查了，都初始化了，也合法，那你就多读点儿吧“。这就是dynamic_cast和RTTI的联系。

有一个实际问题，当我们需要判断该指针实际指向的类型的时候，假如我们加了一堆ifelse然后用dynamic cast判断，这非常慢，尤其是继承非常复杂的时候，效率非常低。需要注意。所以很多引擎的RTTI是自己的。

dynamic_cast 在传入引用和指针的时候不一样。

• 使用指针的时候，如果可以转换则传回真正的地址。
• 如果不可以则会返回0（nullptr）表示转换失败

但是使用引用的时候却不可以这样。首先，引用不能像指针那样设置为0。设置为0代表着有一个临时对象产生出来，然后这个临时对象初始值为0，然后这个引用成为了这个临时对象的别名。（右值相关，对吧。）

• 所以使用引用的时候，如果可以转换则会把对象引用至正确的子类。
• 但是如果失败，由于引用不可以传0，则会抛出一个bad_cast_exception

给一般读者：#

• 常量指针（指向常量的指针）被转化成非常量的指针（或逆向），并且仍然指向原来的对象；
• 常量引用被转换成非常量的引用（或逆向），并且仍然指向原来的对象；
• 不改变原指针/引用的常量状态。
• 不可进行类型更改，只能进行CV操作。

我们来看代码：

1
using namespace std;
2
class multiple{
3
    public:
4
    multiple():valc(0){}
5
    multiple(int x, int y, int z):vala(x), valb(y), valc(z){}
6
    int vala;
7
    int valb;
8
    const int valc;
9

10
};
11

12
int main()
13
{
14
    multiple p(1,3,5);
15
    const multiple* const_ptr = &p;           //指向常量的指针
16
    //---------------------------------------------------------------------
17
    const_ptr = const_cast<multiple*> (const_ptr);    //进行const cast
18
    const_ptr->vala = 100;                //不可以, 必须要赋值给新的指针。
19
    const_cast<multiple*> (const_ptr)->vala = 100;     //可以
20

21
    //---------------------------------------------------------------------
22
    multiple* ptr = const_cast<multiple*> (const_ptr);  //赋值给新指针
23
    ptr->vala = 10;                    //可以
24
    ptr->valc = 100;                  //不可以。因为valc是常量。
25
}

1
void Function(int &val){
2
    cout<<val<<endl;
3
}
4
int main(){
5
    const int value=21;
6
    Function(value);          //不可以
7
    Function(const_cast<int&>(value));  //转换为常量引用，可以
8
    return 0;
9
}

1
int main(){
2
    int value=26;
3
    const int* const_ptr=&value;
4
    *const_ptr=3;              //不可以
5
    int* ptr=const_cast<int*>(const_ptr);  //转换为非常量指针。可以
6
    *ptr=3;
7
    return 0;
8
}

给能思考的读者。因为这里我还没有完全弄明白，可能存在错误#

原因是全局const在静态区。不能间接修改。因为这个内存段所属的页面的权限是只读的，硬写一定会段错误。而局部const在栈上。这个内存段所属的页面是可读也可写的，所以可以间接修改。但是修改任何标记为const的变量都是未定义行为。

我们直接看代码

1
class multiple{
2
    public:
3
    multiple():valc(0){}
4
    multiple(int x, int y, int z):vala(x), valb(y), valc(z){}
5
    int vala;
6
    int valb;
7
    const int valc;
8

9
};
10
int main()
11
{
12
    const multiple np(2,4,6);          //常量对象
13
    multiple ucnp = const_cast<multiple&>(np);  //这里下面会解释
14
    ucnp.vala = 10;
15
    //---------------------------------------------------------
16
    cout << ucnp.vala<< endl;            //输出10
17
    cout << ucnp.valb<< endl;            //输出4
18
    cout << ucnp.valc<< endl;            //输出6
19
    //---------------------------------------------------------
20
    cout << np.vala<< endl;            //输出2
21
    cout << np.valb<< endl;            //输出4
22
    cout << np.valc<< endl;            //输出6
23
}

这里面我们进行const_cast的时候返回值并没有使用引用来接受。这是可以的。这里会产生一个临时变量做为中间值传给了结果值

有没有注意到问题，我们的np不是引用，是个对象。可能无法直观感受，我们接着看

这句话不知道对不对。来自：https://www.cnblogs.com/dracohan/p/3417842.html

下面有更狠的。

我们把ucnp换成引用。看看结果如何

1
int main()
2
{
3
    const multiple np(2,4,6);          //常量对象
4
    multiple& ucnp = const_cast<multiple&>(np);  //注意这里
5
    ucnp.vala = 10;
6
    //---------------------------------------------------------
7
    cout << ucnp.vala<< endl;            //输出10
8
    cout << ucnp.valb<< endl;            //输出4
9
    cout << ucnp.valc<< endl;            //输出6
10
    //---------------------------------------------------------
11
    cout << np.vala<< endl;            //输出10
12
    cout << np.valb<< endl;            //输出4
13
    cout << np.valc<< endl;            //输出6
14
}

好像没什么问题啊？确实是这样的嘛。常量引用转换成非常量引用，有啥问题？

你再仔细看一眼。np是什么？是对象啊。这是个常量对象啊，我们修改了常量对象啊！

我们可以来一个更明显的例子：

1
int main{
2

3
    multiple p(1,3,5);
4
    cout << p.valc << endl;          //输出5
5
    int& wtf = const_cast<int&>(p.valc);  //修改常量。
6
    wtf = 1000;
7
    cout << p.valc << endl;          //输出1000
8
    return 0;
9
}

我们的valc是一个const int。但是这里我们修改了一个对象里的常量。

以上操作，编译器没有任何警告。但是这应该是一个未定义行为。需要避免修改任何已经声明为常量的对象。const_cast只能正确转换顶层（引用，指针）的常量性质，但是无法正确转换底层（引用的本体，指针指向的对象）的常量性质。强行转换会导致未定义行为。

• const_cast的一些错误使用可能不会让编译器报错。但是它不会做你想要让它做的，

const_cast的正确使用方式#

假设有如下代码

1
class my_array{
2
    public:
3
      const char& operator[](size_t offset) const{
4
            return buffer[offset]
5
        }
6
      char& operator[](size_t offset){
7
            return const_cast<char&>(const_cast<const my_array&>(*this)[offset])
8
        }
9
    private:
10
      char buffer[10];
11
};
12
int main(){
13
    const my_array c_arr;
14
    my_array arr;
15
    return 0;
16
}

• 这种情况下，与其写两个函数，不如让非const的调用const。具体过程如下。
• 如果是const对象调用，则正确匹配至const成员函数。
• 如果是非const对象调用，则正确匹配至非const成员函数。在非const成员函数内，我们先把自己cast成const引用，必须是引用否则就新建对象了。然后这时候调用operator[]会匹配到const的成员函数。这时候返回的是const char&。然后再把这个带const的cast成char&。这样做是安全的，因为传入的数组本来就不是const的，可以修改。我们只是把自己cast成了const引用。但是本身还是非const。

C风格cast的过程#

来自这里

只有一个形参#

1
class A
2
{
3
public:
4
    A(int i):a(i){}     //单参构造函数
5
    int getValue()
6
    {
7
        return a;
8
    };
9
private:
10
    int a;
11
};

1
int main(){
2
    A a = 10;      //case1
3
    A a(10);      //case2 注意这是直接初始化，不会受到explicit限制。
4
    A a;        //case3
5
    a = 10;
6
    return 0;
7
}

case1中，我们没有临时对象。而是直接把10作为参数传递给类型转换构造函数。使用了拷贝初始化（先调用默认构造，再调用拷贝构造）这虽然使用了”=“，但是实际上我们在创建新对象。创建新对象的时候一律是拷贝构造而不是拷贝赋值。因为对象还不存在

case2中，我们没有临时对象，使用直接初始化调用默认构造。

case3中，我们有临时对象。编译器执行 a = 10;的时候相当于先使用 A(10);在栈中创建了一个临时对象。然后再调用对象a的拷贝赋值 a(10) 给a初始化（因为对象a已经存在）。然后临时对象销毁。这就是编译器做的隐式转换工作。

也就是说，如果我们使用了explicit，这里将会变成：

1
A a;
2
a = A(10);   //显式调用构造函数 禁止隐式转换

多个形参但是只有一个没有默认值#

1
class A
2
{
3
public:
4
    A(int i, int j = 5):a(i),b(j){}     //单参构造函数
5
    int getValue()
6
    {
7
        return a;
8
    };
9
private:
10
    int a;
11
    int b;
12
};

原理和上面一样。但是有一个知识点：函数默认值假如第N个参数有，那么N后面的参数必须全都有。

发生隐式转换的条件#

注意！四种情况会发生隐式转换：

• 混合类型的算数运算表达式。

1
int a = 3;
2
double b = 4.5;
3
a + b; // a将会被自动转换为double类型，转换的结果和b进行加法操作

• 不同类型的赋值操作。（这里包含拷贝初始化）

1
int a = true ; ( bool 类型被转换为 int 类型)
2
int * ptr = null;（null被转换为 int *类型）

• 函数参数传值

1
void func(double a);
2
func(1); // 1被隐式的转换为double类型1.0

• 函数返回值。（此处例子）

1
double add( int a, int b)
2
{
3
    return a + b;
4
} //运算的结果会被隐式的转换为double类型返回

针对第四种我们举个例子。看代码：

1
class tmp{
2
    public:
3
    string _text;
4
    tmp(string c): _text(c) {}      //单参构造，可以看做转换构造
5

6
};
7
class test{
8
    public:
9
    string _text;
10
    test(string a): _text(a){}    //单参构造，可以看做转换构造
11
    test(tmp s): _text(s._text){}  //单参构造，可以看做转换构造。此处入参是tmp类型，return一个test类型，可以看成tmp可以转为test
12
};
13
class twonumber{
14
    public:
15
    test ret(){
16
        test(tmp("cde"));
17
        return(tmp("abc")); //此处返回的对象是一个tmp，但是函数头的返回类型却是test。可以运行。这里使用了构造函数的隐式转换。使用了临时对象
18
        return(test(tmp("abc"))); //如果设置了explicit，则需要这样进行显式转换。
19
    }
20
    //!由于return语句内是隐式转换，所以对应的构造函数如果有explicit关键字则无法进行隐式转换。即便这里看起来像拷贝初始化。
21

22
};
23
int main(){
24
    twonumber ttt;
25
    test rrr = ttt.ret();
26
    cout << rrr._text << endl;
27
    return 0;
28
}

1
test ret(){
2
        test(tmp("cde"));
3
        return(tmp("abc"));
4
}

1
void changesomething(string& s){
2
    //改变一些东西
3
}

说到底，我们啥时候想禁用呢？#

• 当类中同时存在“non-explicit-one-argument 构造函数和类型转换函数的时候。有可能产生二义性。所以需要对“non-explicit-one-argument构造函数前加explicit防止编译器隐式自动转换类型
• explicit可以理解为，在拷贝初始化的时候，尝试去对等号右侧对象进行一个隐式转换以满足等号左侧的类型要求。但是explicit会让隐式转换序列中，忽略掉explicit标注的类型转换函数（转换构造函数或用户定义的类型转换函数）。所以他会找不到对应的转换方式所以约等于禁止隐式转换了。
• 也就是说，如果加了explicit，使用拷贝初始化的时候我们就必须用显式类型转换。比如C风格cast或c++风格的cast或显式调用构造函数进行直接初始化。
  • 显式地调用构造函数进行直接初始化实际上是显式类型转换的一种。

再次重申，explicit只限制拷贝初始化，不限制直接初始化。而且对象类型为本类类型的时候不限制。因为如果是本类类型不涉及任何类型转换。

1
A a(5);    //可以。直接初始化
2
A a = 5;  //不可以，拷贝初始化。
3
A b(a);    //可以。对象类型为本类，不属于类型转换。不发生隐式转换。
4
A b = a;  //可以。对象类型为本类，不属于类型转换。不发生隐式转换。

• 可以进行多种构造函数的搭配自由使用

1
class obj{
2
    public:
3
        obj(){};
4
        obj(int a):val1(a){};
5
        explicit obj(int a, int b):val1(a), val2(b){};
6
    int val1;
7
    int val2;
8
};
9

10
int main(){
11
    obj t1; //可以，有默认构造函数
12
    obj t2(10,20); //可以，explicit只能限制拷贝初始化。这里是直接初始化。
13
    obj t3 = (10,20);//不可以，禁止隐式类型转换。
14
    obj t4 = obj(10,20);//可以，显式类型转换。
15
    obj t5 = (20); //可以。因为这个构造函数没有被explicit修饰
16

17
    vector<obj> myvec{obj(10,20), (20)}; //可以这样搭配使用。
18

19
    return 0;
20
}

所以explicit卡在哪儿了？卡在隐式类型转换所需的构造等号右侧的临时对象了。#

我们上面提到了如果其他对象的类型不是目标类型或从目标类型派生，那就需要找能转换的转换序列（包括转换构造函数和用户定义转换函数）。说人话就是我们要使用等号右面的这个东西，构建出一个等号左边的类型的临时对象。但是在这个临时对象的构造中（转换序列的查找中），忽略掉所有带explicit声明符的可用函数。这时候自然就防止了隐式类型转换。因为一般情况下，我们期望的是提供一系列参数，然后进行对象构造。按理说直接初始化提供的参数和拷贝初始化提供的参数是相同的。因为在拷贝初始化临时对象后，会调用拷贝构造或移动构造来对左侧的对象进行初始化。

但是，它有时候想的和你不太一样。比如

1
explicit myobj(int x):val(new int(x)){ //explicit
2
    cout <<"const" << endl;
3
}
4
myobj(int x, int y = 20):val(new int(x)){ //带默认值
5
    cout <<"const with default value" << endl;
6
}
7
myobj b = 10; //可以
8

9
/*
10
const with default value
11
mv
12
dest
13
dest
14
*/

• 这个时候为啥可以呢？因为尽管通过10来构造myobj临时对象的时候，第一个匹配的构造函数是explicit不能用，但是第二个可以用。所以此时依旧可以拷贝初始化。

类型转换函数和void#

我们看下面代码：

1
#include <iostream>
2

3
struct S {
4
  operator void() {
5
    std::cout << "F";
6
  }
7
};
8

9
int main() {
10
  S s;
11
  (void)s; // 无输出
12
  static_cast<void>(s); // 无输出
13
  s.operator void(); //输出 F
14
}

为什么前两个无输出？因为标准说了:

可以定义转换到（可有 cv 限定的）自身类（或它的引用），转换到它自身类的基类（或它的引用），和转换到类型 void 的转换函数，但它无法作为转换序列的一部分执行，除非在某些情况下通过虚派发来执行：

也就是说，用户定义转换函数永远不会被用于转换一个类型到它的自身类，自身类的基类，和void。如果想这么用，必须手动调用。

[class.conv.fct]4:

A conversion function is never used to convert a (possibly cv-qualified) object to the (possibly cv-qualified) same object type (or a reference to it), to a (possibly cv-qualified) base class of that type (or a reference to it), or to cv void.

来自CppQuiz 和 这篇StackOverflow

隐式类型转换定义#

当且仅当 T2 能从表达式 e 复制初始化，即对于虚设的临时对象 t，声明 T2 t = e; 良构（能编译）时，称表达式 e 可隐式转换到 T2。注意这与直接初始化（T2 t(e)）不同，其中还会额外考虑显式构造函数和转换函数。

转换构造函数#

上文explicit提到过

类型转换函数#

就在上面。

对于需要进行隐式转换的上下文，编译器会生成一个隐式转换序列：

1. 零个或一个由标准转换规则组成的标准转换序列，叫做初始标准转换序列
2. 零个或一个由用户自定义的转换规则构成的用户定义转换序列
3. 零个或一个由标准转换规则组成的标准转换序列，叫做第二标准转换序列

对于隐式转换发生在构造函数的参数上时，第二标准转换序列不存在。

初始标准转换序列：#

初始标准转换序列很好理解，在调用用户自定义转换前先把值的类型处理好，比如加上cv限定符：

1
struct A {};
2
struct B {
3
    operator A() const;
4
};
5

6
const B b;
7
const A &a = b;