C++面向对象2

原创已于 2022-05-07 09:46:50 修改 · 608 阅读

0 ·

CC 4.0 BY-SA版权

转载请标明出处

文章标签：

#c++ #开发语言

于 2022-05-07 09:46:33 首次发布

C++入门专栏收录该内容

22 篇文章

订阅专栏

本文介绍了C++中面向对象的几个关键概念：析构函数的语法和作用，动态分配对象内存的原理，类的作用域以及作用域操作符的使用，以及类的静态成员变量和静态成员函数的详细解释。重点讨论了析构函数在内存管理中的角色，以及静态成员如何为类的所有对象共享数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

析构函数

析构函数与构造函数先后对应，析构函数就是用来收尾释放内存的函数。

析构函数语法：

//面向对象
//作者：分解机226

#include <iostream>
using namespace std;

class BOLI
{
public:
	BOLI(int a, int b) :a(a), b(b)
	{
		cout << "构造函数被调用" << endl;
	}
	~BOLI()
	{
		cout << "析构函数被调用" << endl;
	}
	void DB()
	{
		cout << "a=" << a << ",b=" << b << endl;
	}
private:
	int a, b;
};

int main()
{
	BOLI boli(520, 1314);
	boli.DB();
	return 0;
}

析构函数与构造函数一样与类同名，不同的是析构函数前面加了一个波浪线，一般情况下析构函数是不会被自动调用的，这里是因为对象boli在main（）函数中被创建，所以他是分配在栈上的，在主函数结束时会自动销毁。

动态分配对象内存：

我们在使用new时会调用构造函数，使用delete会调用析构函数，我们可以使用两者来动态分配内存。

//面向对象
//作者：分解机226

#include <iostream>
using namespace std;

class BOLI
{
public:
	BOLI(int a, int b) :a(a), b(b)
	{
		cout << "构造函数被调用" << endl;
	}
	~BOLI()
	{
		cout << "析构函数被调用" << endl;
	}
	void DB()
	{
		cout << "a=" << a << ",b=" << b << endl;
	}
private:
	int a, b;
};

int main()
{
	BOLI* d = new BOLI(520, 1314);
	d->DB();
	delete d;
	d = new BOLI(4665, 456);
	d->DB();
	delete d;
	return 0;
}

我们可以直观的看到，每次使用new的时候构造函数都会被调用，每次使用delete的时候析构函数都会被调用。

//面向对象
//作者：分解机226

#include <iostream>
using namespace std;


class BOLI
{
public:
	BOLI(int size) :size(size)
	{
		arr = new int[size];
		for (int i = 0; i < size; i++)
		{
			arr[i] = i;
		}
	}
	~BOLI()
	{
		delete[] arr;
	}
	void d()
	{
		for (int i = 0; i < size; i++)
		{
			cout << arr[i] << "\t";
		}
		cout << endl;
	}
private:
	int* arr;
	int size;
};

int main()
{
	BOLI DB(5);
	DB.d();
	return 0;
}

上面一段代码虽然在类的内部使用了动态内存分配，但是由于对象创建在栈上，因此析构函数会被自动调用，不i会有内存遗漏。

类的作用域

一个类的创建就确定了一块独一无二的作用域，两个类中可以声明重名的函数和变量，这是因为在大多数情况下我们都是通过类的对象来访问成员的，但是也有些例外，所以我们要掌握域操作符的用法。

作用域操作符

//面向对象
//作者：分解机226

#include <iostream>
using namespace std;

class BOLI
{
public:
	BOLI()
	{

	}static int num;
private:
};
int BOLI::num = 2;
int num = 3;

int main()
{
	cout << "BOLI::num的值是" << BOLI::num << endl;
	cout << "num的值是" << num << endl;
	return 0;
}

上面的一段代码使用了作用域操作符，在全局作用域中我们定义了两个num其中没有BOLI：的是普通的全局变量，有BOLI：的是类的静态成员变量，在类定义中就声明了一次。

//面向对象
//作者：分解机226

#include <iostream>
using namespace std;

class BOLI
{
public:
	BOLI()
	{
		
	}
	static void printBOLI()
	{
		cout << "print BOLI" << endl;
	}
};

class DAIJIE
{
public:
	DAIJIE() {}
	void printBOLI()
	{
		BOLI::printBOLI();
	}
private:
	int num;
};

int main()
{
	DAIJIE daijie;
	daijie.printBOLI();
	return 0;
}

我们使用作用域操作符可以轻易的使用另一个类的成员函数，而不存在类与类之间明显的边界，只要求我们需要访问的成员处于合法的访问权限即可。

类的静态成员

类的静态局部变量与函数的局部变量的区别在于，静态变量的生命周期是贯穿整个程序的而不是一次的函数调用，静态变量只在函数内部可见。类的静态成员分为静态成员变量和静态成员函数。

类的静态成员变量

类的静态成员变量的生命周期与类绑定，它的作用域是类，也就是在类的所有对象中都是可见的。

//面向对象
//作者：分解机226

#include <iostream>
using namespace std;

class BOLI
{
public:
	BOLI(float price):price(price){}
	float getprice()
	{
		return discountrate * price;
	}
private:
	float price;
	static float discountrate;
};

float BOLI::discountrate = 0.85;

int main()
{
	BOLI camera(2299.99);
	cout << "相机的最总价格是" << camera.getprice() << endl;
	BOLI tv(1199.99);
	cout << "电视价格" << tv.getprice() << endl;
	return 0;
}

上面的一段代码，使用静态成员变量定义了一个商品对象通用的折扣变量，只需要初始化一次，就可以在该类的实例对象的getprice()函数中使用，之后还可以改变这个值，如果我们使用一般的成员变量，这样的修改就要在所有对象中都修改一遍。静态成员变量初始化就像全局变量一样，要在全局作用域中进行。这是因为静态成员变量的生命周期是全局的，在初始化静态成员变量时要省略关键字static，还需要加一个类的限定符“BOLI::”。

类的静态成员函数

静态成员函数作用于类，而不是作用于具体对象，

//面向对象
//作者：分解机226

#include <iostream>
#include <string>
using namespace std;

class BOLI
{
public:
	BOLI(int id,string name):id(id),name(name){}
	static int generateID()
	{
		return globalID++;
	}
	string getname()
	{
		return name;
	}
	int getId()
	{
		return id;
	}
private:
	string name;
	int id;
	static int globalID;
};

int BOLI::globalID = 1;

int main()
{
	BOLI boli1(BOLI::generateID(), "张三");
	cout << boli1.getname() << "的学号是" << boli1.getId() << endl;
	BOLI boli2(BOLI::generateID(), "历史");
	cout << boli2.getname() << "的学号是" << boli2.getId() << endl;
}