C++ 类和对象（中）

比昨天多敲两行2026-01-25 8:40

类的默认成员函数

默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。

⼀个类，我 们不写的情况下编译器会默认⽣成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最 后两个取地址重载不重要，我们稍微了解⼀下即可。

构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并 不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化 对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数⾃动调⽤的 特点就完美的替代的了Init。

构造函数的特点：

  1. 函数名与类名相同。

  2. ⽆返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)

  3. 对象实例化时系统会⾃动调⽤对应的构造函数。

  4. 构造函数可以重载。

上面4点用代码来示范：

cpp 复制代码 
#include<iostream>
using namespace std;
//构造函数是特殊的函数，它没有返回值
class Date
{
public:	
	Date()// 1.⽆参构造函数
	{
	_year = 1;
	_month = 1;
	_day = 1;
	}
	
	Date(int year, int month, int day)// 2.带参构造函数
    {
	_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();err
	d1.Print();
	//调用带参构造函数
	Date d2(2025,12,31);
	d2.Print();
	return 0;
}
//构造函数Date d1的函数名跟类名相同
//构造函数Date d1没有返回值
//对象实例化构造函数Date d1与构造函数Date d2时，自动调用对应构造函数
//构造函数Date d1与构造函数Date d2构成重载

  1. 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显 式定义编译器将不再⽣成。

  2. ⽆参构造函数、全缺省构造函数 、我们不写构造时**编译器默认⽣成的构造函数，都叫做默认构造函 数。**但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成 函数重载，但是调⽤时会存在歧义。要注意很多人会认为默认构造函数是编译器默认⽣成那个叫 默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调 ⽤的构造就叫默认构造。

cpp 复制代码 
#include<iostream>
using namespace std;
//构造函数是特殊的函数，它没有返回值
class Date
{
public:	
	//Date()// 1.⽆参构造函数
	//{
	//_year = 1;
	//_month = 1;
	//_day = 1;
	//}
	
	//Date(int year, int month, int day)// 2.带参构造函数
    //{
	//_year = year;
	//_month = month;
	//_day = day;
    //}

	// 3.全缺省构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
	_year = year;
	_month = month;
	_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
 
    }
private:
	int _year;
	int _month;
	int _day;
};
//1和3构成函数重载，但存在调用歧义。所以不能同时存在。
//有3时，就不需要2。所以，以上三种构造函数只能出现一种
int main()
{
	//调用无参构造函数
	Date d1;//不能写成Date d1();err
	d1.Print();
	//调用带参构造函数
	Date d2(2025,12,31);
	d2.Print();
	//调用全缺省构造函数
	Date d3(2026);
	d3.Print();
	return 0;
}
  1. 我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始 化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始 化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤ 初始化列表才能解决。
cpp 复制代码 
#include<iostream>
using namespace std;
//让编译器自动生成默认构造函数
class Date
{
public:	
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
 
    }
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	
	Date d1;
	d1.Print();

	return 0;
}

结果没完成初始化（VS22版本）：

析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的， 函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对 象中资源的清理释放⼯作。析构函数的功能类⽐我们之前Stack实现的Destroy功能，⽽像Date没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

  1. 析构函数名是在类名前加上字符'~' （类似按位取反符，正对应析构函数功能跟构造函数相反）。

  2. ⽆参数⽆返回值。(这⾥跟构造类似，也不需要加void)。

  3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。

  4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数。

  5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会 调⽤他的析构函数。

  6. 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类 型成员⽆论什么情况都会⾃动调⽤析构函数。

  7. 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如 果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时，⼀定要 ⾃⼰写析构，否则会造成资源泄漏，如Stack。

  8. ⼀个局部域的多个对象，C++规定后定义的先析构。

cpp 复制代码 
//两个栈实现队列举例
#include<iostream>
typedef int STDataType;
using namespace std;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc fail");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	~Stack()//栈的析构函数，如果不写就会内存泄漏
	{
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}
private:
	STDataType* _a;
	size_t _capacity ,_top;
};

class MyQueue
{
public:
	Stack pushst;
	Stack popst;
};

int main()
{
	//后定义的先析构，这里先析构st2
	Stack st1;
	Stack st2;
	//MyQueue mq;//mq的析构不用写，它会自动调用两个栈的析构
	return 0;
}

对⽐⼀下⽤C++和C实现的Stack解决之前括号匹配问题isValid，我们发现有了构造函数和析构函数确 实⽅便了很多，不会再忘记调⽤Init和Destory函数了，也⽅便了不少。

赋值运算符重载

运算符重载

一些整型，浮点型的数据比较大小(+,-,*,/)是系统自定义的，比较简单且系统支持。

但是像我们自定义的日期类的比较大小，系统是不支持的，因为我们定义日期类时是不确定的，有时要精确到秒，有时只比较到天数。所以像日期这种类型的比较要我们自己定义，就要用到运算符重载。

  1. 当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规 定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编 译报错。

  2. 运算符重载是具有特殊名字的函数 ，他的名字是由operator和后⾯要定义的运算符共同构成。和其 他函数⼀样，它也具有其返回类型和参数列表以及函数体。

  3. 重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元 运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。

cpp 复制代码 
#include<iostream>
using namespace std;

class Date
{
public:	

    Date(int year = 1, int month = 1, int day = 1)
    {
    _year = year;
    _month = month;
    _day = day;
    }

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
 
    }

//private:
	int _year;
	int _month;
	int _day;
};
//比如我要比较两个日期类相不相等
//函数返回类型由运算符决定（'=='相等则为true，否则为false）
//函数参数要看一元还是二元的
bool operator==(const Date& d1, const Date& d2)
{
  return d1._year == d2._year
  && d1._month == d2._month
  && d1._day == d2._day;
}

int main()
{
	
	Date x1(2024, 7, 5);
    Date x2(2024, 7, 6);

    operator==(x1, x2);//显⽰调⽤运算符重载函数

    x1 == x2;//编译器会转换成operator==(d1, d2); 若没有写对应的运算符重载函数则会编译报错。
	return 0;
}
  1. 如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算 符重载作为成员函数时，参数⽐运算对象少⼀个。

上面的写法把私有变量暴露出来了，不安全，改进一下：

cpp 复制代码 
#include<iostream>
using namespace std;

class Date
{
public:	

    Date(int year = 1, int month = 1, int day = 1)
    {
    _year = year;
    _month = month;
    _day = day;
    }

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
 
    }
//解决方法：放到类里面重载成成员函数
//第⼀个运算对象默认传给隐式的this指针，因此运算 符重载作为成员函数时，参数⽐运算对象少⼀个
    bool operator==(Date& d2)
    {
      return _year == d2._year
      && _month == d2._month
      && _day == d2._day;
    }

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	
	Date x1(2024, 7, 5);
    Date x2(2024, 7, 6);

    //operator==(x1, x2);
    //x1 == x2;

    x1.poerator==(x2);
    x1==x2;//这种写法会自动转换上面的 x1.poerator==(x2);
	return 0;
}
  1. 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。

6.不能通过连接语法中没有的符号来创建新的操作符：比如operator@。

  1. .*，：： ，sizeof，？：，**.**以上5个运算符不能重载。

8.一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义，但是重载operator+就没意义。

9.重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，比如：int operator+（int x，int y）。

10.重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法区分。

C++规定，后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。

11.重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。

重载为全局函数把ostream/istream放到第一个形参位置就可以了，第二个形参位置当类类型对象。

拷⻉构造函数

如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引**⽤**，且任何额外的参数都有默认值，则此构造函数 也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。

拷⻉构造的特点：

1.拷⻉构造函数是构造函数的⼀个重载。

  1. 拷⻉构造函数的第⼀个参数必须是类类型对象的引⽤ ，使⽤传值⽅式编译器直接报错，因为语法逻 辑上会引发⽆穷递归调⽤。拷⻉构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引 ⽤，后⾯的参数必须有缺省值。

  2. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返 回都会调⽤拷⻉构造完成。

  3. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成 员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构 造。

  4. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完 成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但 是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要 我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型 Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现 MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就 需要显⽰写拷⻉构造，否则就不需要。

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

cpp 复制代码 
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// 编译报错 "Date": ⾮法的复制构造函数: 第⼀个参数不应是"Date" 
//Date(Date d)
Date(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}
        Date(Date* d)
        {
                _year = d->_year;
                _month = d->_month;
                _day = d->_day;
        }
        void Print()
        {
                cout << _year << "-" << _month << "-" << _day << endl;
        }
private:
        int _year;
        int _month;
        int _day;
};
void Func1(Date d)
{
        cout << &d << endl;
        d.Print();
}

// Date Func2()
Date& Func2()
{
    Date tmp(2024, 7, 5);
    tmp.Print();
    return tmp;  

}
int main()
{
        Date d1(2024, 7, 5);
        // C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥传值传参要调⽤拷⻉构造
        // 所以这⾥的d1传值传参给d要调⽤拷⻉构造完成拷⻉，传引⽤传参可以减少这⾥的拷⻉
 
        Func1(d1); 
        cout << &d1 << endl;

        Date d2(&d1); // 这⾥可以完成拷⻉，但是不是拷⻉构造，只是⼀个普通的构造
        d1.Print();
        d2.Print();
    
 
        Date d3(d1);//这样写才是拷⻉构造，通过同类型的对象初始化构造，⽽不是指针
        d2.Print();
        
 
        Date d4 = d1;// 也可以这样写，这⾥也是拷⻉构造
        d2.Print();
        
    
        Date ret = Func2();   // Func2返回了⼀个局部对象tmp的引⽤作为返回值
        ret.Print();          // Func2函数结束，tmp对象就销毁了，相当于了⼀个野引⽤
      
        
        return 0;
}

赋值运算符重载

赋值运算符重载 是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷⻉赋值 ，这⾥要注意跟 拷⻉构造区分，拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象。

赋值运算符重载的特点：

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

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

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

4.像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的赋值运算符重载就 可以完成需要的拷⻉，所以不需要我们显⽰实现赋值运算符重载。像Stack这样的类，虽然也都是 内置类型，但是_a指向了资源，编译器⾃动⽣成的赋值运算符重载完成的值拷⻉/浅拷⻉ 不符合我 们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部 主要是⾃定义类型Stack成员，编译器⾃动⽣成的赋值运算符重载会调⽤Stack的赋值运算符重载， 也不需要我们显⽰实现MyQueue的赋值运算符重载。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现 了析构并释放资源，那么他就需要显⽰写赋值运算符重载，否则就不需要。

cpp 复制代码 
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date(const Date& d)
    {
        cout << " Date(const Date& d)" << endl;
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

   
    // d1 = d2;
    Date& operator=(const Date& d) // 传引⽤返回减少拷⻉
    { 
            _year = d._year;
            _month = d._month;
            _day = d._day;
        
        // d1 = d2表达式的返回对象应该为d1，也就是*this 
        return *this;
    }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 7, 5);

// 拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象
Date d2(d1);// 需要注意这⾥是拷⻉构造，不是赋值重载 


// 请牢牢记住赋值重载完成两个已经存在的对象直接的拷⻉赋值
Date d3(2024, 7, 6);
d1 = d3;

Date d4 = d1;
return 0;
}

const成员函数

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

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

图解：

cpp 复制代码 
#include<iostream>
using namespace std;

class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
// void Print(const Date* const this) const
void Print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
const 
int main()
{
// 这⾥⾮const对象也可以调⽤const成员函数是⼀种权限的缩⼩
Date d1(2024, 7, 5);
d1.Print();
const Date d2(2024, 8, 5);
d2.Print();
return 0;
}

取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载 ，⼀般这两个函数编译器⾃动 ⽣成的就可以够我们⽤了，不需要去显⽰实现。除⾮⼀些很特殊的场景，⽐如我们不想让别⼈取到当前类对象的地址，就可以⾃⼰实现⼀份，胡乱返回⼀个地址。

cpp 复制代码 
class Date
{ 
public :
Date* operator&()
{
return this;
// return nullptr;
}
const Date* operator&()const
{
return this;
// return nullptr;
}
private :
int _year ; // 年
 
int _month ; // ⽉
 
int _day ; // ⽇
 
};
相关推荐
hzb666662 小时前
basectf2024
开发语言·python·sql·学习·安全·web安全·php
智者知已应修善业2 小时前
【整数各位和循环求在0-9范围】2024-10-27
c语言·c++·经验分享·笔记·算法
燃于AC之乐2 小时前
我的算法修炼之路--9——重要算法思想：贪心、二分、正难则反、多重与完全背包精练
c++·算法·贪心算法·动态规划·二分答案·完全背包·多重背包
superman超哥2 小时前
序列化性能优化：从微秒到纳秒的极致追求
开发语言·rust·开发工具·编程语言·rust序列化性能优化·rust序列化
Henry Zhu1232 小时前
Qt Model/View架构详解（一）：基础理论
开发语言·qt
Swift社区2 小时前
Java 实战 - 字符编码问题解决方案
java·开发语言
灰灰勇闯IT2 小时前
【Flutter for OpenHarmony--Dart 入门日记】第3篇：基础数据类型全解析——String、数字与布尔值
android·java·开发语言
天天睡大觉2 小时前
python命名规则（PEP8编码规则）
开发语言·前端·python
重生之我是Java开发战士2 小时前
【Python】基础语法入门：变量，数据类型，运算符
开发语言·python
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Claude Code Skills 实用使用手册04Linux下V2Ray安装配置指南05UV安装并设置国内源06BongoCat - 跨平台键盘猫动画工具07Open Code教程（四）| 高级配置与集成08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10MC.JS 网页版《我的世界》 免安装中文版