C++ 类和对象（中篇）

已于 2024-08-31 22:26:59 修改
阅读量855 收藏 23
点赞数 28
分类专栏： C++基础 文章标签： c++
于 2024-08-21 10:54:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SikJ_2020_0_24/article/details/141387088
版权

一、类的6个默认成员函数

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

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

 二、 构造函数

2.1、构造函数的概念

        对于以下Date类：

class Date
 {
 public:
     void Init(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;
     d1.Init(2022, 7, 5);
     d1.Print();
     Date d2;
     d2.Init(2022, 7, 6);
     d2.Print();
     return 0;
 }

        对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置 信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

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

 2.2、构造函数特性

        构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象。

其特征如下：

        1. 函数名与类名相同。

        2. 无返回值。

        3. 对象实例化时编译器自动调用对应的构造函数。

        4. 构造函数可以重载 

class Date
  {
 public:
     // 1.无参构造函数
     Date()
     {}
     // 2.带参构造函数
     Date(int year, int month, int day)
     {
         _year = year;
         _month = month;
         _day = day;
     }
 private:
     int _year;
     int _month;
     int _day;
  };
 void TestDate()
  {
     Date d1; // 调用无参构造函数
     Date d2(2015, 1, 1); // 调用带参的构造函数
     // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
     // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
     // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
     Date d3();
  }

 5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦 用户显式定义编译器将不再生成。

class Date
  {
 public:
     /*
     // 如果用户显式定义了构造函数，编译器将不再生成
    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类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
     // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
     // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
     Date d1;
     return 0;
}

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

        解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类 型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看 下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认构造函数。 

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 = 2000;
     int _month = 6;
     int _day; = 28;
     // 自定义类型
    Time _t;
 };
int main()
 {
     Date d;
     return 0;
 }

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

         注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为 是默认构造函数。简单来说：不传参就可以调用的构造函数就是默认构造函数

 三、 析构函数

3.1、析构函数的概念

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

        析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由 编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

 3.2、析构函数的特性

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

        1. 析构函数名是在类名前加上字符 ~。

        2. 无参数无返回值类型。

        3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载

        4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

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

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类生成的默认析
构函数
// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

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

四、拷贝构造函数

4.1、 什么拷贝构造

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

        拷贝构造：一个已经存在的对象去初始化另一个要创建对象

        赋值：两个已经存在对象进行拷贝

 4.2、 什么拷贝构造的特征

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

        1. 拷贝构造函数是构造函数的一个重载形式。

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

class Date
 {
 public:
     Date(int year = 1900, int month = 1, int day = 1)
     {
         _year = year;
         _month = month;
         _day = day;
     }
// 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;
 }

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

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

        4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？ 当然像日期类这样的类是没必要的。

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

        （1）使用已存在对象创建新对象

        （2）函数参数类型为类类型对象

        （3）函数返回值类型为类类型对象

 五、赋值运算符重载

 5.1、 运算符重载

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

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

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

注意：

（1）不能通过连接其他符号来创建新的操作符：比如operator@

（2）重载操作符必须有一个类类型参数 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义

（3）作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

（5）.*   ::   sizeof    ?:    . 注意以上5个运算符不能重载。

// 全局的operator==
 class Date
 { 
public:
     Date(int year = 1900, int month = 1, int day = 1)
    {
         _year = year;
         _month = month;
         _day = day;
    }    
//private:
 int _year;
 int _month;
 int _day;
 };
 // 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。

bool operator==(const Date& d1, const Date& d2)
 {
     return d1._year == d2._year
         && d1._month == d2._month
         && d1._day == d2._day;
 }
 void Test ()
 {
     Date d1(2018, 9, 26);
     Date d2(2018, 9, 27);
     cout<<(d1 == d2)<<endl;
 }
 class Date
 { 
public:
     Date(int year = 1900, int month = 1, int day = 1)
     {
         _year = year;
         _month = month;
        _day = day;
     }
     // bool operator==(Date* this, const Date& d2)
      // 这里需要注意的是，左操作数是this，指向调用函数的对象
     bool operator==(const Date& d2)
     {
         return _year == d2._year;
             && _month == d2._month
             && _day == d2._day;
 }
 private:
     int _year;
     int _month;
     int _day;
 };

 5.2 赋值运算符重载

5.2.1、 赋值运算符重载格式

参数类型：const 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)
     {
         if(this != &d)
         {
             _year = d._year;
             _month = d._month;
             _day = d._day;
         }
 }
 private:
     int _year ;
     int _month ;
     int _day ;
 };

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

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 =”必须是非静态成员

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

 5.2.3、用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝

注 意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符 重载完成赋值。 

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;
 }

 既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实 现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
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;
 };
 int main()
 {
     Stack s1;
     s1.Push(1);
     s1.Push(2);
     s1.Push(3);
     s1.Push(4);
     Stack s2;
     s2 = s1;
     return 0;
 }

         注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

 5.2.4、 前置++和后置++重载

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(2022, 1, 13);
     d = d1++;    // d: 2022,1,13   d1:2022,1,14
     d = ++d1;    // d: 2022,1,15   d1:2022,1,15
    return 0;
 }

六、 const成员

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

        我们来看看下面的代码： 

class Date
 {
 public:
     Date(int year, int month, int day)
     {
         _year = year;
         _month = month;
         _day = day;
     }
     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();
 }

请思考下面的几个问题：

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

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

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

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

1. 不能，权限被放大了

2. 可以，权限被缩小了

3. 不能，权限被放大了 

4. 可以，权限被缩小了

总结：只读函数都可以加const，内部不涉及修改成员的都是只读函数！ 

七、 取地址及const取地址操作符重载 

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

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

        这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需 要重载，比如想让别人获取到指定的内容！ 

XYLoveBarbecue
关注
专栏目录
C++新特性之一：对语言可用性的增强(中篇）
实战开发者Airex
04-23 142
总第29篇 接上篇，本文继续对C++新特性中的对语言可用性的增强进行归纳介绍。 1.区间迭代的简化 区间迭代是指基于范围的for循环。在C++11中，引入了基于范围的迭代写法，能够写出像python一样简单的循语句： int array[] = {1,2,3,4,5}; for(auto &am...
【C++入门】类和对象（中）
ermu的博客
10-14 4978
类的默认成员函数：构造函数、析构函数、拷贝构造函数、赋值运算符重载等
C++ —— 类的六个默认成员函数
@情话
09-28 2524
类的六个默认成员函数   1. 构造函数   2. 析构函数   3. 拷贝构造函数   4. 赋值操作符重载   5. 取地址操作符重载   6. const修饰的取地址操作符重载 一. 构造函数 class Date { public: void Date(int year, int month, int day) { _year = year; _month = month; _day = day; } private: int _year; int
c++中类的默认成员函数
lyzzs222的博客
08-18 677
必有其存在的道理，在c语言阶段，我们定义一个栈等数据结构，会自己写初始化，清理的函数，如果忘记了清理，会有。内置类型就是int，double，char等系统给定的类型，自定义类型就比如自己定义的类，系统会调用这个类自身的默认构造函数。总结：类的默认成员函数有构造，析构，拷贝，赋值操作符重载，取地址操作符重载，const修饰的取地址操作符重载。灵活运用，默认的不够用，就自己写，根据需求来完成类的成员函数。这个重载自己实现的较少，默认的重载就够了，但是如果想让别人取到特定的地址还是有必要自己实现的。...
【C++】类的默认成员函数
hgelin的博客
09-24 184
1.构造函数 2.拷贝构造函数 3.析构函数、 4.运算符重载---实现一个日期计算器   c++类有6个默认成员函数：构造函数，拷贝构造函数，析构函数，赋值操作符重载。取地址操作符重载，const修饰的取地址操作符重载。其中前四个默认成员函数是我们重点研究对象。 1.构造函数 成员变量为私有的，要对他们进行初始化，必须用一个公有成员函数来进行。同时这个函数有且仅在定义对象时自...
C++:类的默认成员函数
最新发布
Another_Shi的博客
07-19 1010
默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我们不写的情况下编译器会默认⽣成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个。经过编译器处理之后，类A不在为空，它会自动的生成六个默认的成员函数，即使这六个成员函数什么也不做。
【C++基础】三、类和对象（中篇）
大家好我叫张同学
03-30 2728
如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗?并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。构造函数：在对象构造时调用的函数，这个函数完成初始化工作。构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次
类与对象（中篇）
2302_80873119的博客
01-31 1439
类和对象（中）
C++：类和对象（中篇---类的6个默认成员函：构造、析构、拷贝构造、赋值、取地址、const取地址）
ETalien_的博客
02-27 389
类和对象（中篇—类的6个默认成员函数） 如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。 构造函数（初始化） 构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。构造函数是特殊的成员函数，需要注意的是，构造函数的...
C++：默认函数练习——日期类项目的实现
h2608011009的博客
06-14 533
文章目录一：前言二：布局三：实现1、默认成员函数实现（1）全缺省构造函数（2）拷贝构造函数（3）析构函数赋值运算符重载（1）日期 += 天数（2）日期 += 天数（3）日期 + 天数（4）日期 –= 天数（5）日期–天数（6）前置++和后置++（7）前置––和后置––2、比较运算符重载3、日期相减 一：前言 C++类和对象里面的默认成员函数，如构造函数，拷贝构造赋值重载这些问题虽然说是不难，但是想要写出一个标准的类还是具有一定挑战性的。而编写日期类是一个很好的练手项目 此次的博客，为了更好的练习类与对象，完
C++：类的默认成员函数
盒马的博客
01-24 1393
讲解C++类的六大默认成员函数。
类的默认成员函数(C++)
duchenlong的博客
03-20 583
类的默认成员函数类的6个默认成员函数构造函数析构函数拷贝构造运算符重载const 修饰类的成员变量取地址及const取地址操作符重载默认函数实现日期类 之前我们看到，一个空类他其实也是有大小的，但是我们所定义的空类就真的什么也没有，只是一个空类吗？ 类的6个默认成员函数 总的来说，任何一个类在我们什么都不写的情况下，都会自动生成6个默认的成员函数。 构造函数：完成初始化工作 析构函数：完成清理函...
c++类默认的成员函数
漫鱼
06-16 926
空类的大小 构造函数 默认构造函数 拷贝构造函数 默认拷贝构造函数 析构函数 关于构造和析构的顺序 运算符重载 友元函数的出现 static修饰类成员 C++中的const 内联函数 空类的大小 class Person { }; sizeof(Person) //1 空类的大小为1.因为实例化类后为每个对象分配内存空间，若要是0空间，对象会被分配到...
C++ 类默认成员函数
个人技术博客
11-08 185
一、类默认成员函数 在原有4个特殊成员函数（构造函数、析构函数、复制构造函数、复制赋值运算符）的基础上。C++11又新增了两个：移动构造函数与移动赋值运算符。构造函数与析构函数前面已经介绍过，下面分别介绍其余四个函数 1、复制构造函数 复制构造函数（也可以叫拷贝构造函数）是一种特殊的构造函数，它在创建对象时，使用同一类中之前创建的对象来初始化新创建的对象。如果在类中没有定义拷贝构造函数，编译器会自行定义一个。下面是一个复制构造函数常见的结构： classname (const classname &
C++类の默认成员函数
weixin_51765479的博客
07-13 510
默认成员函数
类和对象中
weixin_43215068的博客
03-15 153
类的6个默认成员函数 1.构造函数 构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员 都有 一个合适的初始值，并且在对象的生命周期内只调用一次。 构造函数特点 构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主 要任务并不是开空间创建对象，而是初始化对象。 其特征如下： 函数名与类名相同。 无返回值。 对...
【C++】类的6个默认成员函数
m0_64538862的博客
02-09 1089
1. 类的6个默认成员函数2. 构造函数3. 析构函数4. 拷贝构造函数5.1运算符重载5.2赋值运算符重载5.3前置++和后置++重载，前置--和后置--重载5.4日期类的实现6. const成员函数7. 取地址及const取地址操作符重载
C++空类中的默认成员函数
qq_39998031的博客
02-26 232
默认成员函数： 1、默认构造函数 2、析构函数 3、拷贝构造函数 4、赋值运算符（等号：operator=） 5、取址运算符（operator&amp;amp;）（一对，一个非const的，一个const的）-----有争议，跟具体编译器相关，有的生成，有的不生成 class Empty { public: Empty(); // ...
C++类的六个默认成员函数（总结）
neuzhangno的博客
08-25 500
C++类的六个默认成员函数（总结）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值