定义一个类

  • 类中的成员变量及函数的访问权限如果未设置，则默认是私有 ```cpp

    include

    using namespace std;

const double PI = 3.14;

class Circle{ private: int m_r;//半径

  1. //获取周长
  2. public: double calculateZC(){
  3.     return 2 * PI * m_r;
  4. }
  6. //设置半径
  7. public: void setR(int r){
  8.     m_r = r;
  9. }

};

int main() { Circle circle; circle.setR(20);

  1. cout << circle.calculateZC() << endl;
  2. return 0;

}

  1. > 125.6
  4. <a name="QOHK2"></a>
  5. ### 构造函数及析构函数
  6. 默认情况下，编译器至少会给一个类自动生成三个函数
  8. - 默认构造函数，函数体为空
  9. - 默认析构函数，函数体为空
  10. - 默认拷贝构造函数，对属性的值进行拷贝
  12. 这三个方法都可以不声明，编译器会自动添加实现。构造主要用于做一些初始化操作，析构则是进行清理工作，拷贝函数则用于拷贝当前对象（如值传递）。
  13. ```cpp
  14. #include <iostream>
  15. using namespace std;
  17. const double PI = 3.14;
  19. class Circle{
  21.     //无参/默认 构造函数
  22.     public:Circle(){}
  25.     //有参析构函数
  26.     public:Circle(int r){
  27.         m_r = r;
  28.     }
  30.     private: int m_r;//半径
  33.     //获取周长
  34.     public: double calculateZC(){
  35.         return 2 * PI * m_r;
  36.     }
  38.     //设置半径
  39.     public: void setR(int r){
  40.         if(r>0){
  41.             m_r = r;
  42.         }
  43.     }
  45.         //设置半径
  46.     public: int getR(){
  47.         return m_r;
  48.     }
  51.     //析构函数，回收对象时会执行该方法
  52.     ~Circle(){
  54.     }
  56. };
  58. int main()
  59. {
  60.     Circle circle1;//调用默认构造函数不可以加括号，因为编译器会以为在调用函数
  61.     circle1.setR(1);
  63.     Circle circle2(2);//调用有参数构造函数的方法一
  65.     Circle circle3 = Circle(3);//调用有参构造函数的方法二
  67.     Circle circle4 = 4;//调用有参构造函数的方法三
  69.     cout <<"第一个圆的半径为："<<circle1.getR()<<",周长为："<< circle1.calculateZC() << endl;
  70.     cout <<"第二个圆的半径为："<<circle2.getR()<<",周长为："<< circle2.calculateZC() << endl;
  71.     cout <<"第三个圆的半径为："<<circle3.getR()<<",周长为："<< circle3.calculateZC() << endl;
  72.     cout <<"第四个圆的半径为："<<circle4.getR()<<",周长为："<< circle4.calculateZC() << endl;
  73.     return 0;
  74. }

第一个圆的半径为：1,周长为：6.28 第二个圆的半径为：2,周长为：12.56 第三个圆的半径为：3,周长为：18.84 第四个圆的半径为：4,周长为：25.12

拷贝构造函数

如果没有声明拷贝构造函数，则编译器会自动生成，所以如果不需要对拷贝的内容进行调整，不需要声明该方法

  1. #include <iostream>
  2. using namespace std;
  4. const double PI = 3.14;
  6. class Circle{
  8.     //无参/默认 构造函数
  9.     public:Circle(){
  10.         cout << "调用默认构造函数" << endl;
  11.     }
  14.     //拷贝构造函数(参数必须是常量引用且同类型)
  15.     public:Circle(const Circle& c){
  16.         cout << "调用拷贝构造函数" << endl;
  17.         m_r = c.m_r;
  18.     }
  20.     private: int m_r;//半径
  23.     //获取周长
  24.     public: double calculateZC(){
  25.         return 2 * PI * m_r;
  26.     }
  28.     //设置半径
  29.     public: void setR(int r){
  30.         if(r>0){
  31.             m_r = r;
  32.         }
  33.     }
  35.         //设置半径
  36.     public: int getR(){
  37.         return m_r;
  38.     }
  41.     //析构函数，回收对象时会执行该方法
  42.     ~Circle(){
  44.     }
  46. };
  48. void doWork(Circle c){
  49.     cout <<"圆的半径为："<<c.getR()<<",周长为："<< c.calculateZC() << endl;
  50. }
  52. int main()
  53. {
  54.     Circle circle1;//调用默认构造函数不可以加括号，因为编译器会以为在调用函数
  55.     circle1.setR(1);
  57.     Circle circle2(circle1);//调用拷贝构造函数初始化对象
  59.     doWork(circle1);//由于调用函数是值传递，值传递时编译器会自动调用拷贝构造函数然后创建一个临时对象进行传参
  60.     return 0;
  61. }

编译器调用拷贝构造函数的时机

  • 开发者主动调用拷贝函数进行初始化的情况
  • 采用值传递的方式进行函数传参时，编译器会调用拷贝构造函数对传参的对象进行拷贝

默认拷贝函数的问题

编译器的默认实现是浅拷贝，这种情况如果数据是存在堆上（也就是new出来的），那么浅拷贝会出现问题。

  • 浅拷贝：简单的赋值拷贝操作

  • 深拷贝：在堆区重新申请空间（new），进行拷贝操作

  • 一个浅拷贝带来的问题的案例

错误版本：

  1. #include <iostream>
  2. using namespace std;
  4. const double PI = 3.14;
  6. class Circle{
  8.     public:int* m_r = 0;//半径
  10.     public:Circle(int r){
  11.         m_r = new int(r);
  12.     }
  15.     //拷贝构造函数(参数必须是常量引用且同类型)
  16.     public:Circle(const Circle& c){
  17.         cout << "调用拷贝构造函数" << endl;
  18.         m_r = c.m_r;//这里是浅拷贝，也是编译器的默认实现
  19.     }
  21.     ~Circle(){
  22.         if(m_r != NULL){
  23.             delete m_r;//最终问题出在这里，m_r由于是浅拷贝，两个对象里delete的其实是同一个变量，delete了两次
  24.         }
  25.     }
  27. };
  29. int main()
  30. {
  31.     Circle circle1(12);
  33.     Circle circle2(circle1);//调用拷贝构造函数初始化对象
  34.     return 0;
  35. }

修改后：

  1. #include <iostream>
  2. using namespace std;
  4. const double PI = 3.14;
  6. class Circle{
  8.     public:int* m_r = 0;//半径
  10.     public:Circle(int r){
  11.         m_r = new int(r);
  12.     }
  15.     //拷贝构造函数(参数必须是常量引用且同类型)
  16.     public:Circle(const Circle& c){
  17.         cout << "调用拷贝构造函数" << endl;
  18.         m_r = new int(*c.m_r);//开辟新的堆空间
  19.     }
  21.     ~Circle(){
  22.         if(m_r != NULL){
  23.             delete m_r;
  24.         }
  25.     }
  27. };
  29. int main()
  30. {
  31.     Circle circle1(12);
  33.     Circle circle2(circle1);//调用拷贝构造函数初始化对象
  34.     return 0;
  35. }