C++类和对象笔记2

最新推荐文章于 2026-02-25 16:15:30 发布

原创最新推荐文章于 2026-02-25 16:15:30 发布 · 1.6k 阅读

本内容遵循CC 4.0 BY-SA版权协议

1.析构函数

析构函数和构造函数的功能恰好相反，析构函数不是必须让我们完成对对象本身的销毁，比如一个类里面只有内置类型（int...）的类型，我们就不用手动去实现一个析构函数，这时候编译器自己生成的析构函数已经可以帮助我们去释放资源了。但是如果是我们向内存申请的空间，就像c语言中链表的节点类似的，就需要我们去手动释放空间，手动完成析构函数。

1.析构函数的函数名是类名的前面加'~'；

2.析构函数无参数无返回值；（和构造函数类似，也是不用加void等等的）

3.一个类里面只能有一个析构函数，如果我们没有显式定义，编译器也会自动生成析构函数。

4.对象生命周期结束的时候，编译器会自动调用析构函数。

5.析构函数在对自定义类型处理的方式和构造函数类似，我们不实现对自定义类型的析构，编译器会自动去调用自定义类型的析构函数。

6.析构函数的顺序按照栈的顺序来析构，也就是后进先出，后面定义的变量最前析构。

#include <iostream>
using namespace std;

class Stack
{
public:
//构造函数
	Stack(int n = 4)
	{
		_a = (int*)malloc(sizeof(int));
		if (_a == nullptr)
		{
			perror("malloc");
			exit(1);
		}
		_capacity = n;
		_size = 0;
	}
//析构函数
	~Stack()
	{
		cout << "Stack()" << endl;
		free(_a);
		_a = nullptr;
		_size = _capacity = 0;
	}

private:
	int* _a;
	int _capacity;
	int _size;
};

class MyQueue
{
public:
//写了析构函数，他也会去调用自定义类型的析构函数
	~MyQueue()
	{
		cout << "~MyQueue ";
	}
private:
//两个自定义类型
	Stack pushst;
	Stack popst;
};

int main()
{
	Stack st;

	MyQueue mq;

	return 0;
}

2.拷贝构造函数

如果一个构造函数的第一个参数是自身类型的引用，并且任何额外的参数都有默认值，那么这个构造函数也就是拷贝构造函数，所以拷贝构造函数是构造函数的特殊形式。

1.拷贝构造函数可以和构造函数构成重载函数。

2.拷贝构造函数的第一个传参必须是类型对象的引用。如果是类对象的传值，那么就会引起编译器报错。

3.拷贝构造函数也可以有多个参数，但是第一个参数必须是类型对象的引用，后面的参数也必须有缺省值。

4.自定义类型对象进行拷贝必须调用拷贝构造，所以自定义类型传值和传值返回都会调用拷贝构造完成。

5.如果我们没有显示实现拷贝构造，编译器也会自动生成拷贝构造函数，自动生成的拷贝构造函数是对内置类型成员变脸完成值拷贝(一个字节字节的拷贝)，对自定义类型成员变量会调用它的拷贝构造函数。

6.如果一个类显示实现了析构并释放资源，那么它就需要显示写拷贝构造，否则就不需要。

7.传值返回会产生一个临时对象的调用拷贝构造，传引用返回，返回的是返回对象的引用，没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束的时候就会销毁，这时候使用传引用返回是有问题的，就相当于返回了一个空指针，一个已经销毁了的对象，所以我们在返回的时候一定要确保对象存在。

#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(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
//指针的拷贝构造函数
//因为我不想改变d的指向和d指向的值，所以我使用了两个const来修饰
	Date(const Date* const d)
	{
		_year = d->_year;
		_month = d->_month;
		_day = d->_day;
	}

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

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

Date& T()
{
	Date tmp(2222, 2, 2);
	return tmp;
}

int main()
{
	Date a(2026, 2, 2);

	Date b = a;
	Date rb(a);
	b.Print();
	rb.Print();
	Date c = &a;
	Date rc(&a);
	c.Print();
	rc.Print();

	Date d = T();
	d.Print();

	return 0;
}

//关于栈的拷贝构造的探索
#include <iostream>
using namespace std;

class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (int*)malloc(sizeof(int) * n);
		if (_a == nullptr)
		{
			perror("malloc");
			exit(1);
		}
		_capacity = n;
		_top = 0;
	}
	Stack(const Stack& st)
	{
		//这里是拷贝构造，需要先_a开辟和st一样大的空间大小
		//然后再拷贝
		_a = (int*)malloc(sizeof(int) * st._capacity);
		if (_a == nullptr)
		{
			perror("malloc");
			exit(1);
		}
		memcpy(_a, st._a, sizeof(int) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	void Push(int x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			int* tmp = (int*)realloc(_a, newcapacity * sizeof(int));
			if (tmp == NULL)
			{
				perror("realloc fail");
				exit(1);
			}
			_a = tmp;
			_capacity = newcapacity;
		}

		_a[_top++] = x;
	}

	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	int* _a;
	int _capacity;
	int _top;
};

int main()
{
	return 0;
}

关于函数指针的复习

函数指针和函数一样，返回值和传参必须是相同的。例如：void fun(); 返回值是void，函数名是fun，参数没有；我们可以先创建一个函数指针和上面函数的类型和传参是相同的，但是不知道指向的函数指针：void (*”名字“)();这个就是一个函数指针了，只不过是一个空的指针。

这就是创建一个函数指针的方法，所以 void (A::*sf)() = A::fun;这就是直接创建一个sf的函数指针指向的是A类域里面的fun函数。

typedef void (* pf)();这个意思就是我定义 void (*)() 这个类型的名字是pf。

//函数指针的复习
#include <iostream>
using namespace std;

//int operator+(int x, int y)
//{
//	return x + y;
//}

class A
{
public:
	void fun()
	{
		cout << "A::fun()" << endl;
	}
};
//定义一个函数指针的名字是PF，作用的类域是A里面，是一个无参数无返回值的函数指针。
//但是不知道指向哪一个函数。
typedef void(A::* PF)();

int main()
{

	void (A:: * pp)() = &A::fun;
//创建一个函数指针的变量pf，指向A类域里面的fun函数，所以pf就是A类域里面的fun函数的指针了。
//下面就可以解引用直接使用A类域里面的fun函数。
	PF pf = &A::fun;
	A obj;
	(obj.*pf)();
	(obj.*pp)();
	return 0;
}