【C++基础】类与对象(中)：默认成员函数、构造函数、析构函数、拷贝构造、赋值重载函数……-阿里云开发者社区

👻内容专栏： C/C++编程

🐨本文概括： C++基础语法。六大默认构造函数简介、构造函数、析构函数、拷贝构造函数、赋值重载函数、const成员函数、取地址重载等。

🐼本文作者：阿四啊

🐸发布时间：2023.9.7

类的六个默认成员函数

如果一个类中什么成员都没有，简称为空类。

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员

函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

构造函数

我们在写好一个类的时候，比如说栈(Stack)，创建了一个对象st，但偶然地却忘记Init初始化，然后去做各种各样的Push、Pop操作，没有初始化，那么我们的数据就是随机值，那么运行就很可能会导致程序奔溃。下面我们就有了构造函数的概念。

构造函数概念

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任

务并不是开空间创建对象，而是初始化对象。

其特征如下：

函数名与类名相同。
无返回值(不需要写void）。
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载(可以写多种构造函数，提供多种初始化方式。)

以Date日期类为例，演示无参和带参两种构造函数。

#include <iostream>
using namespace std;
class Date
{
public:
  //1.无参构造函数
  Date()
  {
    _year = 1;
    _month = 1;
    _day = 1;
  }
  //2.带参构造函数
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  //无参构造 注意：不能写成Date d1()，编译器会误认为成函数  
  Date d1;
  d1.Print();
  //带参构造
  Date d2(2023, 9, 6);
  d2.Print();
  return 0;
}

打印上述代码结果：

1/1/1
2023/9/6

提示：大家可以试着写一段日期的代码，然后写一个构造函数，利用F10调试起来，发现编译器确实会调用构造函数。

编译器生成的默认构造函数的特点

🤔关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？

💡C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如/int/char/任意指针类型…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员去调用的它的默认构造函数(如果没有默认构造函数，就会出现报错，这里解决的方案有个语法叫做初始化列表，会在类和对象(下)讲解)。

class Time
{
public:
Time()
{
  cout << "Time()" << endl;
  _hour = 0;
  _minute = 0;
  _second = 0;
}
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
private:
  // 基本类型(内置类型)
  int _year;
  int _month;
  int _day;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d;
return 0;
}

⚠️注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在

类中声明时可以给默认值。

class Time
{
public:
  Time()
  {
    cout << "Time()" << endl;
    _hour = 0;
    _minute = 0;
    _second = 0;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
private:
  // 基本类型(内置类型)
  int _year = 1970;
  int _month = 1;
  int _day = 1;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d;
  return 0;
}

总结：

类中显式定义了构造函数，编译器将不再生成；

对于内置类型的成员不做处理(不是特定的标准，有的编译器会做初始化。在C++11语法中，成员变量声明支持给予缺省值。)，自定义类型的成员才会处理，会去调用这个成员的默认构造函数(注意：如果没有默认构造函数，就会出现报错，这里解决的方案有个语法叫做初始化列表，会在类与对象(下)讲解)。

一般情况下都需要我们自己写构造函数，决定初始化方式，成员变量全是自定义类型，可以考虑不写构造函数。

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

不用传递任何参数就可以调用，就是默认构造。

析构函数

析构函数概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由

编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

特性

析构函数是特殊的成员函数，其特征如下：

析构函数名是在类名前加上字符 ~。
无参数无返回值类型。
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数(内置类型的成员，不做处理，自定义类型的成员，会去调用它的析构函数)。⚠️注意：析构函数不能重载
对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class Stack
{
public:
  Stack(size_t capacity = 3)
  {
    _array = (DataType*)malloc(sizeof(DataType) * capacity);
    if (nullptr == _array)
    {
      perror("malloc申请空间失败!!!");
      return;
    }
    _capacity = capacity;
    _size = 0;
  }
  void Push(DataType data)
  {
    // CheckCapacity();
    _array[_size] = data;
    _size++;
  }
  // 其他方法...
  ~Stack()
  {
    if (_array)
    {
      free(_array);
      _array = nullptr;
      _capacity = 0;
      _size = 0;
    }
  }
private:
  DataType* _array;
  int _capacity;
  int _size;
};
int main()
{
  Stack s1;
  s1.Push(1);
  s1.Push(2);
  Stack s2;
  s2.Push(3);
  s2.Push(4);
  return 0;
}

⚠️注意：s1与s2都在函数栈帧里面，栈帧的规则通常遵循后进先出，所以编译器会先调用s2的析构函数再调用s1的析构函数。

关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

class Time
{
public:
  ~Time()
  {
  cout << "~Time()" << endl;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
private:
  // 基本类型(内置类型)
  int _year = 1970;
  int _month = 1;
  int _day = 1;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d;
  return 0;
}
// 程序运行结束后输出：~Time()
// 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
// 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,
//_day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对
//象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：
//main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date
//类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部
//调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
//main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如
Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

拷贝构造函数

利用stack对象拷贝会出现程序奔溃

我们在C语言学习时期，知道结构体可以拷贝，下面是一份日期类Date的拷贝：

class Date
{
public:
  //1.无参构造函数
  Date()
  {
    _year = 1;
    _month = 1;
    _day = 1;
  }
  //2.带参构造函数
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << "/" << _month << "/" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
void func(Date d)
{
  d.Print();
}
int main()
{
  Date d1(2023, 9, 1);
  func(d1);
}

在func函数内打印对象d，可以成功打印：

2023/9/1

但是，对于栈Stack这个类去拷贝给另一个类，就会出问题了！

class Stack
{
public:
  Stack(size_t n = 4)
  {
    if (n == 0)
    {
      _array = nullptr;
      _top = _capacity = 0;
    }
    else
    {
      _array = (int*)malloc(sizeof(int) * n);
      if (!_array)
      {
        perror("malloc fail\n");
        exit(-1);
      }
      _top = 0;
      _capacity = n;
    }
  }
  void Push(int x)
  {
    _array[_top++] = x;
  }
  ~Stack()
  {
    if (_array)
    {
      free(_array);
      _array = nullptr;
      _capacity = _top = 0;
    }
  }
private:
  int* _array;
  int _top;
  int _capacity;
};
void func2(Stack s2)
{
  s2.Push(1);
}
int main()
{
  Stack s1;
  func2(s1);
  return 0;
}

运行此代码，最后导致程序崩溃。

什么原因呢？

其实是调用了两次析构函数，_array指向的空间被释放了两次。

s1对象在拷贝给s2对象时，不仅会把_top和_capacity拷贝给它，更核心的是，会把_array指向的空间给s2，这样导致s2对象的_array指向的空间与s1对象的_array指向的空间一致，那么在main函数结束前，编译器会先调用s2的析构函数(此时，_array所指向的空间已经被释放了)，再去调用s1的析构函数，那么s1再去释放_array就是一个野指针问题了!

解决方案：

引用传递参数

void func2(Stack& s2)
{
  s2.Push(1);
}

我们给形参添加上‘&’引用，问题可以得到解决，但是s2.Push不就是给s1对象本身也压入了数据吗？那么如果不想要更改s1的数据呢？让我们看看第二种方案，那就是拷贝构造！接下来，让拷贝构造闪亮登场吧！

拷贝构造函数概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

int main()
{
  Stack s1;
  Stack s2(s1);//拷贝构造 
  return 0;
}

拷贝构造函数特征

拷贝构造函数也是特殊的成员函数，其特征如下：

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须是同类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  //Date d2(d1)
  // Date(const Date d) // 错误写法：编译报错，会引发无穷递归
  Date(const Date& d) // 正确写法
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  Date d2(d1);
  return 0;
}

这里有一点难得理解，拷贝构造函数参数必须是同类型对象的引用，否则会出现无穷递归的情况，Date d2(d1)需要调用拷贝构造函数，若将d2的地址传递给this指针，d1传递给d，发现是值传递，会去一直调用拷贝构造，会形成死递归的情况，所以我们需要在拷贝构造形参部分，给同类型对象加上引用。

那么对于前面的程序奔溃的问题，我们就需要用拷贝构造函数来修改它。由原来的浅拷贝改为深拷贝即可，给被拷贝的对象再malloc一个和拷贝对象一样大的空间，利用memcpy()函数将数据也同时拷贝过来。

Stack(const Stack& s)
{
    //深拷贝
    _array = (int*)malloc(sizeof(int)*s._capacity);
    if (!_array)
    {
      perror("malloc fail\n");
      exit(-1);
    }
    memcpy(_array, s._array, sizeof(int)*s._top);
    _top = s._top;
    _capacity = s._capacity;
}

若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Time
{
public:
  Time()
  {
    _hour = 1;
    _minute = 1;
    _second = 1;
  }
  Time(const Time& t)
  {
    _hour = t._hour;
    _minute = t._minute;
    _second = t._second;
    cout << "Time::Time(const Time&)" << endl;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
private:
  // 基本类型(内置类型)
  int _year = 1970;
  int _month = 1;
  int _day = 1;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d1;
  // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
  // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构
  //造函数
  Date d2(d1);
  return 0;
}

⚠️注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

总结：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。（像Date日期这样的类不需要我们实现拷贝构造，自己生成就可以；像Stack栈这样的类需要我们实现拷贝构造，否则就会出问题）。

拷贝构造函数典型调用场景：

使用已存在对象创建新对象
函数参数类型为同类型对象
函数返回值类型为同类型对象

class Date
{
public:
  Date(int year, int minute, int day)
  {
    cout << "Date(int,int,int):" << this << endl;
  }
  Date(const Date& d)
  {
    cout << "Date(const Date& d):" << this << endl;
  }
  ~Date()
  {
    cout << "~Date():" << this << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
Date Test(Date d)
{
  Date temp(d);
  return temp;
}
int main()
{
  Date d1(2022,1,13);
  Test(d1);
  return 0;
}

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

赋值运算符重载

运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.*、::、 sizeof、?:、. 注意这5个运算符不能重载。

👇重载为全局函数：

// 全局的operator==
class Date
{
public:
  Date(int year = 2023, int month = 9, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  //private:
  int _year;
  int _month;
  int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者重载为成员函数。
bool operator< (const Date& d1, const Date& d2)
{
  if (d1._year < d2._year)
  {
    return true;
  }
  else if (d1._year == d2._year && d1._month < d2._month)
  {
    return true;
  }
  else if (d1._year == d2._year && d1._month == d2._month && d1._day < d2._day)
  {
    return true;
  }
  else
  {
    return false;
  }
}
void Test()
{
  Date d1(2023, 9, 6);
  Date d2(2023, 9, 7);
  cout << (d1 < d2) << endl;
  //
  cout << operator<(d1, d2) << endl;
}
int main()
{
  Test();
}

👇重载为类成员函数

// 全局的operator==
class Date
{
public:
  Date(int year = 2023, int month = 9, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  //d1 < d2
  //d1.operator < (d2)
  //这里需要注意的是，左操作数是this，指向调用函数的对象
  bool operator< (const Date& d)
  {
    if (_year < d._year)
    {
      return true;
    }
    else if (_year == d._year && _month < d._month)
    {
      return true;
    }
    else if (_year == d._year && _month == d._month && _day < d._day)
    {
      return true;
    }
    else
    {
      return false;
    }
  }
private:
  int _year;
  int _month;
  int _day;
};

赋值运算符重载

🔗赋值概念：使用已存在对象赋值(复制)给另一个已存在的对象。

赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

class Date
{
public :
//构造函数
Date(int year = 1900, int month = 1, int day = 1)
{
  _year = year;
  _month = month;
  _day = day;
}
//拷贝构造
Date (const Date& d)
{
  _year = d._year;
  _month = d._month;
  _day = d._day;
}
//赋值重载函数
//参数可以不用添加引用，但是需要调用一次拷贝构造，需要重新开辟一段空间
//传递引用可以提高传参效率
//Date& operator=(const Date d)
Date& operator=(const Date& d)
{
  if(this != &d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
  return *this;
}
private:
  int _year;
  int _month;
  int _day;

赋值运算符只能重载成类的成员函数不能重载成全局函数

class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
  _year = year;
  _month = month;
  _day = day;
  }
  int _year;
  int _month;
  int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
  if (&left != &right)
  {
    left._year = right._year;
    left._month = right._month;
    left._day = right._day;
  }
  return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

💡原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

《C++ primer 第5版》500页 `Note`：我们可以重新赋值运算符。不论形参的类型什么，赋值运算符都必须定义为成员函数。

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
注意：内置类型成员变量是直接赋值的(浅拷贝)，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值(深拷贝)。

class Time
{
public:
  Time()
  {
  _hour = 1;
  _minute = 1;
  _second = 1;
  }
Time& operator=(const Time& t)
{
  if (this != &t)
  {
    _hour = t._hour;
    _minute = t._minute;
    _second = t._second;
  }
  return *this;
}
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
  private:
  // 基本类型(内置类型)
  int _year = 1970;
  int _month = 1;
  int _day = 1;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d1;
  Date d2;
  d1 = d2;
  return 0;
}

既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实现吗？当然像日期类这样的类是没必要的。那么对于Stack栈这样的类，用到赋值重载函数，运行和拷贝构造函数一样，会造成程序崩溃。

//这里没写赋值重载函数，编译器就会生成默认的赋值运算符重载函数，只能完成浅拷贝，最后调用析构函数，会释放两次空间，导致程序崩溃！
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
  _array = (DataType*)malloc(capacity * sizeof(DataType));
  if (nullptr == _array)
  {
    perror("malloc申请空间失败");
    return;
  }
  _size = 0;
  _capacity = capacity;
}
void Push(const DataType& data)
{
  // CheckCapacity();
  _array[_size] = data;
  _size++;
}
~Stack()
{
  if (_array)
  {
  free(_array);
  _array = nullptr;
  _capacity = 0;
  _size = 0;
  }
}
private:
  DataType *_array;
  size_t _size;
  size_t _capacity;
};

所以，和拷贝构造函数一样，如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

`前置++` 和 `后置++` 重载

我们前面实现的一些操作符重载，一般都是两个参数，但是对于前置++和后置++，都是一个参数，那么我们想写一个操作符重载函数，如何去区分前置++和后置++呢？

C++规定：前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载，后置++重载时多增加了一个int类型的参数，与前置++构成函数重载，以区分前置++，但调用函数时该参数不用传递，编译器自动传递。

class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
  _year = year;
  _month = month;
  _day = day;
}
// 前置++：返回+1之后的结果
// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
Date& operator++()
{
  _day += 1;
  return *this;
}
// 后置++：
// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
//自动传递
// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
//一份，然后给this+1
// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
Date operator++(int)
{
  Date temp(*this);
  _day += 1;
  return temp;
}
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d;
  Date d1(2023, 1, 1);
  d = d1++; // d: 2023,1,1 d1:2023,1,2
  d = ++d1; // d: 2023,1,3 d1:2023,1,3
  return 0;
}

实现日期类

具体实现我已经总结为另一篇博客啦😜，👉【传送门】

const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

⚠️注意：因为this指针是隐含的，所以我们给成员函数加上const，需要在函数的()后添加。

📌如下所示：

//相当于void Print(const Date* this)
void Print() const
{
  //打印日期……
}

来看看下面这段代码：

class Date
{
public:
Date(int year, int month, int day)
{
  _year = year;
  _month = month;
  _day = day;
}
//Print与const修饰的Print构成函数重载
void Print()
{
  cout << "Print()" << endl;
  cout << "year:" << _year << endl;
  cout << "month:" << _month << endl;
  cout << "day:" << _day << endl << endl;
}
void Print() const
{
  cout << "Print()const" << endl;
  cout << "year:" << _year << endl;
  cout << "month:" << _month << endl;
  cout << "day:" << _day << endl << endl;
}
private:
  int _year; // 年
  int _month; // 月
  int _day; // 日
};
void Test()
{
  Date d1(2022,1,13);
  d1.Print(); //权限的缩小
  const Date d2(2022,1,13);
  d2.Print();//权限的平移
}

const修饰的对象只能调用const成员函数，非const修饰的对象对于const成员函数和非const成员函数，会去调用最匹配的，即非const成员函数，如果非const成员函数不存在，则调用const成员函数。

⚠️：那么const成员函数的意义何在呢？现在大家观察不出来，我们后面在STL的vector部分会深刻感受到。

这里简单理解一下：

这里有一个operator[]操作符重载函数，可以理解为数组访问操作符_a[0]，对于不同的场景，会有读或者写的权限，对于写的场景，比如_a[2] = 10，编译器就会调用非const修饰的成员函数，对于读的场景，我们不希望会被修改，那么编译器就会调用const修饰的成员函数。

📌那么，对于只读函数我们可以加上const修饰，因为不涉及对类的成员进行修改。但是并不是所有的成员函数我们都添加const。

💡那么，思考一下下面的几个问题：

const对象可以调用非const成员函数吗？

不可以，属于权限的放大

非const对象可以调用const成员函数吗？

可以，属于权限的缩小

const成员函数内可以调用其它的非const成员函数吗？

不可以，属于权限的放大

非const成员函数内可以调用其它的const成员函数吗？

可以，属于权限的缩小

取地址及const取地址操作符

这两个默认成员函数一般不用重新定义，编译器默认会生成。

class Date
{
public :
  Date* operator&()
  {
    return this ;
  }
  const Date* operator&()const
  {
    return this ;
  }
private :
  int _year ; // 年
  int _month ; // 月
  int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需

要重载，比如不想让他人取到有效地址。

Date* operator&()
{
  return nullptr;
}
const Date* operator&() const
{
  return nullptr;
}

【C++基础】类与对象(中)：默认成员函数、构造函数、析构函数、拷贝构造、赋值重载函数……

类的六个默认成员函数

构造函数

构造函数概念

特性

编译器生成的默认构造函数的特点

析构函数

析构函数概念

特性

拷贝构造函数

利用stack对象拷贝会出现程序奔溃

解决方案：

引用传递参数

拷贝构造函数概念

拷贝构造函数特征

赋值运算符重载

运算符重载

赋值运算符重载

`前置++` 和 `后置++` 重载

实现日期类

const成员

取地址及const取地址操作符

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【C++基础】类与对象(中)：默认成员函数、构造函数、析构函数、拷贝构造、赋值重载函数……

类的六个默认成员函数

构造函数

构造函数概念

特性

编译器生成的默认构造函数的特点

析构函数

析构函数概念

特性

拷贝构造函数

利用stack对象拷贝会出现程序奔溃

解决方案：

引用传递参数

拷贝构造函数概念

拷贝构造函数特征

赋值运算符重载

运算符重载

赋值运算符重载

前置++ 和 后置++ 重载

实现日期类

const成员

取地址及const取地址操作符

热门文章

最新文章

相关课程

相关电子书

相关实验场景

`前置++` 和 `后置++` 重载