C++基础入门：类和对象（中）

◆博主名称：少司府

欢迎来到少司府的博客☆*: .｡. o(≧▽≦)o .｡.:*☆

⭐数据结构系列个人专栏：

初阶数据结构_少司府的博客-CSDN博客

⭐编程基础训练系列个人专栏：

编程基础50题_少司府的博客-CSDN博客

⭐名不显时心不朽，再挑灯火看文章

目录

一、类的默认成员函数

二、构造函数

[2.1 构造函数作用](#2.1 构造函数作用)

[2.2 构造函数特点](#2.2 构造函数特点)

三、析构函数

[3.1 析构函数的作用](#3.1 析构函数的作用)

[3.2 析构函数的特点](#3.2 析构函数的特点)

四、赋值运算符重载

[4.1 运算符重载](#4.1 运算符重载)

[4.2 赋值运算符重载](#4.2 赋值运算符重载)

五、拷贝构造函数

[5.1 拷贝构造函数定义](#5.1 拷贝构造函数定义)

[5.2 拷贝构造函数特点](#5.2 拷贝构造函数特点)

六、取地址运算符重载

[6.1 const 成员函数](#6.1 const 成员函数)

[6.2 取地址运算符重载](#6.2 取地址运算符重载)

---

一、类的默认成员函数

默认成员函数是用户没有显示实现、编译器会自动生成的函数。一个类，不写时编译器默认生成6个成员函数，C++11以后增加2个，移动构造和移动赋值。

二、构造函数

2.1 构造函数作用

构造函数的本质作用就是：在对象实例化时初始化对象。

2.2 构造函数特点

1）、函数名与类名相同。

2）、⽆返回值。（没有void）

3）、对象实例化时系统会调用对应的构造函数

4）、可以重载

class Date
{public:
    Date() //无参构造函数
    {
        _year=1;
        _month=1;
        _day=1;
    }
    Date(int year,int month,int day) //带参
    {
        _year=year;
        _month=month;
        _day=day;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1; // 无参构造函数不能加括号
    Date d2(2026,4,7);
    return 0;
}

5）、全缺省构造函数与无参构造函数不能同时存在

6）、类中没有显示定义构造函数，编译器会默认生成无参构造函数

7）、无参、全缺省、编译器默认生成的都叫默认构造函数，这三个有且仅有一个存在

8）、编译器生成的构造，对内置类型的成员初始化没有要求，也就是是否初始化是不确定的；对于自定义类型的成员，要求调用这个成员变量的默认构造函数初始化。没有这个成员变量的默认初始化函数会报错，需要初始化列表来解决这个报错的成员变量。

class MyQueue
{public:
    //...
 private:
    Stack pushst; 
    Stack popst;
};

这里假设 Stack 类中实现了构造，那么编译器默认生成的 MyQueue 的构造函数调用了 Stack 的构造，完成了两个成员的初始化。

三、析构函数

3.1 析构函数的作用

与构造函数功能相反。析构函数不是对对象本身的销毁，而是对对象中资源的清理释放。

3.2 析构函数的特点

1）、函数名是类名前加上字符~

2）、无参数无返回值

3）、一个类只能有一个析构，未显式定义，系统默认生成

4）、对象生命周期结束时，系统会自动调用析构函数

class Stack
{public:
    Stack()
    {
        //...
    }
    ~Stack()
    {
        free(_a);
        _a=nullptr;
        _top=_capacity=0;
    }
private:
    //...
};

5）、跟构造函数类似，编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会

调⽤他的析构函数（对于自定义类型成员，无论是否显式写析构，都会自动调用它的析构）

6）、如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时（动态开辟空间），⼀定要⾃⼰写析构，否则会造成资源泄漏（内存泄漏），如Stack。

7）、⼀个局部域的多个对象，C++规定后定义的先析构

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
 Stack(int n = 4)
 {
 _a = (STDataType*)malloc(sizeof(STDataType) * n);
 if (nullptr == _a)
 {
 perror("malloc申请空间失败");
 return;
 }
 _capacity = n;
 _top = 0;
 }
 ~Stack()
 {
 cout << "~Stack()" << endl;
 free(_a);
 _a = nullptr;
 _top = _capacity = 0;
 }
private:
 STDataType* _a;
 size_t _capacity;
 size_t _top;
};
// 两个Stack实现队列 
class MyQueue
{
public:
 //编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源 
 // 显⽰写析构，也会⾃动调⽤Stack的析构 
 /*~MyQueue()
 {}*/
private:
 Stack pushst;
 Stack popst;
};
int main()
{
 Stack st;
 MyQueue mq;
 return 0;
}

四、赋值运算符重载

4.1 运算符重载

1）、当运算符被用于类类型对象时，C++允许通过运算符重载的形式指定新的含义。C++规定类类型对象运算时，必须转换成调用相应运算符重载

2）、运算符重载是具有特定名字的函数，他的名字是由 operator 和后面要定义的运算符共同构成

3）、几元运算符就有几元参数

bool operator==(Date d1,Date d2)
{
    return d1._year==d2._year
    && d1._month==d2._month
    && d1._day==d2._day;
}

int main()
{
    Date d1(2026,4,6);
    Date d2(2026,4,7);
    operator==(d1,d2); // 或d1==d2,即赋值重载拷贝
    return 0;
}

4）、如果一个运算符函数是成员函数，则它的第一个运算对象 默认传给隐式的 this 指针，因此运算符重载作为成员函数时，参数比运算对象少一个。

class Date
{public:
    bool operator==(Date d2)
    {
        return _year=d2._year
        && _month==d2._month
        && _day==d2._day;
    }
    //...
private:
    //...
};

d1.operator==(d2);

5）、对于二元操作符，左操作数是第一个参数，右操作数是第二个参数。

6）、运算符重载以后，其优先级和结合性不变

7）、**.* :: sizeof ?: .**这5个操作符不能重载

8）、重载操作符至少有一个类类型参数

9）、重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。

 Date& operator++()
 {
 cout << "前置++" << endl;
 //...
 return *this;
 }

 Date operator++(int)
 {
 Date tmp;
 cout << "后置++" << endl;
 //...
 return tmp;
 };

10）、重载 << 和 >> 时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了 对象<<cout，不符合使⽤习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。

ostream& operator<<(ostream& out,const Date& d)
{
    out << _year << "年" << _month << "月" << _day << "日";
}
// istream、ostream 类型对象（流对象）不支持拷贝（构造），只能传引用

4.2 赋值运算符重载

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

1）、赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const 当前类类型引⽤，否则会传值传参会有拷⻉

2）、有返回值，且建议写成当前类类型引⽤，引⽤返回可以提⾼效率，有返回值⽬的是为了⽀持连续赋值场景。

3）、没有显式实现时，编译器会⾃动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认拷 ⻉构造函数类似，对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉ )，对⾃定义 类型成员变量会调⽤他的赋值重载函数。

class Date
{public:
    //...
    Date& operator=(const Date& d)
     {
         // 检查⾃⼰给⾃⼰赋值的情况 
         if (this != &d)
         {
         _year = d._year;
         _month = d._month;
         _day = d._day;
         }
     // d1 = d2表达式的返回对象应该为d1，也就是*this 
     return *this;
     }
private:
    //...
};

五、拷贝构造函数

5.1 拷贝构造函数定义

第一个参数是自身类类型对象的引用 ，且任何额外的参数都有默认值。这样的构造函数称为拷贝构造函数

5.2 拷贝构造函数特点

1）、拷贝构造函数是构造函数的一个重载

2）、第一个参数必须是自身类类型对象的引用，用传值的方式会引发编译器报错（语法上是无穷递归调用）

class Date
{public:
    Date()
    {
        //...
    }
    Date(const Date& d)
    {
        _year=d._year;
        _month=d._month;
        _day=d._day;
    }
    //...
private:
    //...
}

int main()
{
    Date d1(2026,4,7);
    d1.Print();
    Date d2(d1);
    d2.Print();
    return 0;
};

3）、C++规定自定义类型对 象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。

4）、若未显式定义拷贝构造，编译器会自动生成拷贝构造函数。自动完成的拷贝构造会对内置类型完成值拷贝 /浅拷贝 （一个字节一个字节地拷贝），对于自定义类型会调用它的拷贝构造。

5）、传值返回会产⽣⼀个临时对象调⽤拷⻉构造 ，传引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤ 引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少 拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

六、取地址运算符重载

6.1 const 成员函数

1）、将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。

2）、const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。

void Date::Print()const
{
    //...
}

3）、此时，Print 函数隐含的参数是 const Date* const this ，第二个const是本来就带的，指的是不能更改this指向。

const Date d1(2026,4,7);
d1.Print();

6.2 取地址运算符重载

& 这个取地址运算符是默认成员函数，一般编译器默认实现的就够用了，不用我们自己显式实现。

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

Date* operator&()
{
    return this;
}

本期的分享就到这里，如果觉得博主的文章比较对胃口的话，可以点一个小小的关注~

您的三连是我持续更新的动力~