当前位置：首页 > news >正文

类和对象基础（C++）

news 来源：原创 2024/12/27 23:09:33

1.struct和class的异同

1.1 C语言中的struct

1.2 C++中的struct

1.3 class

2.类的定义

3.访问限定符

3.1访问限定符的作用域

3.2成员属性设置为私有

4.类的默认成员函数

4.1构造函数和析构函数

4.2拷贝构造函数

5.深拷贝和浅拷贝

6.再谈构造函数

6.1初始化列表

6.2类对象作为类成员

6.3静态成员

7.C++对象模型和this指针

7.1成员变量和成员函数分开存储

7.2this指针的概念

7.3空指针访问成员函数

7.4const修饰成员函数

1.struct和class的异同

1.1 C语言中的struct

C语言中，struct可以定义结构体：

struct SNode
{
	struct SNode* next;
	int val;
};

结构体中只能有变量，而不能出现函数。

1.2 C++中的struct

在C++中，兼容了C语言中使用struct定义结构体的语法，而且新增加了一种用法：使用struct定义类。

struct在C++和C语言中的不同点：

C语言定义的结构体中只能出现变量； C++定义的类中可以出现函数。

1.3 class

C++中可以使用struct定义类，也可以使用class来定义类，这两种定义方式也有区别：

struct定义的默认成员时公有的； class定义的默认成员时私有的。

提到公有、私有，就不得不谈一谈访问限定符了。

2.类的定义

语法：class 类名{ 访问权限：属性/行为}；

实例代码：

//设计一个圆类
const double PI = 3.14;
class Circle
{
public:  //访问权限  公共的权限

	//属性
	int m_r;//半径

	//行为
	//获取到圆的周长
	double calculateZC()
	{
		//2 * pi  * r
		//获取圆的周长
		return  2 * PI * m_r;
	}
};

3.访问限定符

三种访问限定符：

public（公有的） 在类内和类外都可以直接访问
protected（保护的）
private（私有的） protected和private都是在类内可以访问，在类外不能访问（具体的区别在继承，在这里不进行区分）

提到类和对象，就少不了访问限定符，类对成员的封装，就借助了访问限定符。

上面我们提到struct定义的类默认是共有的，class定义的类默认是私有的，下面我们写一段程序，来进一步理解：

struct person
{
	const char* name;
	int age;
	void show()
	{
		cout << name << " " << age << endl;
	}
};

int main()
{
	person p1;
	p1.name = "zhangsan";
	p1.age = 18;
	p1.show();
	return 0;
}

默认权限是公有的，在类外和类内都可以直接访问。

把以上代码中的struct 改为class，程序就会报错：

原因就是class定义的类成员默认是私有属性，在类外不能直接访问。

但如果我们在类中使用访问限定符之后，就能解决这个问题：

class person
{
public:
	void show()
	{
		cout << name << " " << age << endl;
	}
	const char* name;
	int age;
	
};

int main()
{
	person p1;
	p1.name = "zhangsan";
	p1.age = 18;
	p1.show();
	return 0;
}

3.1访问限定符的作用域

1.从一个访问限定符到另一个访问限定符。2.从一个访问限定符到类结束。

class person
{
public:  public和private之间的是public属性
	void show()
	{
		cout << name << " " << age << endl;
	}
private:   private到类定义结束时private属性
	const char* name;
	int age;
	
};

3.2成员属性设置为私有

优点：

将所有成员属性设置为私有，可以控制读写权限
对于写权限，可以检测数据的有效性

class Person {
public:
	//姓名设置可读可写
	void setName(string name) {
		m_Name = name;
	}
	string getName()
	{
		return m_Name;
	}
	//获取年龄 
	int getAge() {
		return m_Age;
	}
	//设置年龄
	void setAge(int age) {
		if (age < 0 || age > 150) {
			cout << "你个老妖精!" << endl;
			return;
		}
		m_Age = age;
	}

	//情人设置为只写
	void setLover(string lover) {
		m_Lover = lover;
	}

private:
	string m_Name; //可读可写  姓名
	int m_Age; //只读  年龄
	string m_Lover; //只写  情人
};

4.类的默认成员函数

4.1构造函数和析构函数

对象的初始化和清理是两个非常重要的安全问题，一个对象或者变量没有初始化状态的话，那么造成的后果是严重的。

同样的使用完一个对象或者变量，没有及时清理的话，也会造成安全问题。

C++利用构造函数和析构函数来解决以上问题，这两个函数由编译器自动调用，完成对象的初始化和清理工作；

我们不需要提供构造和析构函数，编译器会提供构造和析构函数的空实现。

构造函数语法：类名（）{}

构造函数，没有返回值也不写void
函数名和类名相同
构造函数可以有参数，因此可以发生重载
程序在调用对象的时候自动进行构造，无需手动调用，而且只调用一次

构造函数的调用规则：

默认情况下，C++编译器至少给一个类添加3个函数

默认构造函数（无参，函数体为空）
默认析构函数（无惨，函数体为空）
默认拷贝函数，对属性进行拷贝

构造函数的调用规则如下：

如果用户定义有参构造函数，C++不会提供默认构造函数，但是会提供拷贝函数
如果用户定义拷贝构造函数，C++不会再提供其他构造函数

//以person类为例
class person
{
public:
	void show()
	{
		cout << name << " " << age << endl;
	}
	person() //构造函数
	{
		cout << "person()" << endl;
	}
private:
	const char* name;
	int age;
	
};

析构函数的语法：~类名（）{}

析构函数也是没有返回值的，也不写void
函数名和类名相同，在名称的前面加上~
析构函数不可以有参数，因此不可以发生重载
程序在对象销毁前自动调用析构函数，无需手动调用，而且只调用一次

class person
{
public:
	//析构函数
	~person()
	{
		cout << "~person()" << endl;
	}

};

4.2拷贝构造函数

class person
{
public:
	person()
	{
		cout << "person()" << endl;
	}
	person(const char* name, int age)
	{
		_name = name;
		_age = age;
	}
private:
	const char* _name;
	int _age;
	
};

int main()
{
	person p1("lisi", 20);//调用构造函数
	person p2(p1);//调用拷贝构造
	return 0;
}

通过调试可以看到，p2初始化的值就是拷贝的p1对象的，而且拷贝构造函数是编译器自动生成的。

5.深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height) {
		
		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);
		
	}
	//拷贝构造函数  
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);
		
	}

	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

浅拷贝可能导致的问题和解决办法：

进行拷贝时，这两个对象指向的是同一块空间，而在使用析构函数对每个对象进行销毁时都会释放这块空间，这就会造成堆区空间重复释放的问题。 解决办法：深拷贝，在堆区开辟不同的空间。

6.再谈构造函数

6.1初始化列表

作用：C++提供了初始化列表的语法，用来初始化属性。

语法：构造函数（）: 属性1（值1），属性2（值2）...{}

代码举栗：

class Person {
public:
	//初始化列表方式初始化
	Person(int a, int b, int c) 
        :m_A(a)
        ,m_B(b)
        ,m_C(c) 
        {}
	void PrintPerson() {
		cout << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};

当然m_A，m_B，m_C也可以在构造函数内部进行初始化，这种成员变量是没有限制的；

但是类中有以下成员的话，就必须使用初始化列表才能进行初始化（不使用初始化列表是错误的）：

引用成员变量
const成员变量
自定义类型成员（且该类中没有默认构造函数）

总结：内置类型可以使用初始化列表，以上三种特殊类型只能使用初始化列表，所以能使用初始化列表的话就使用初始化列表。

6.2类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员。

class A {}
class B
{
    A a；
}

创建和销毁对象的时候有一个顺序问题，构造：先调用A or 先调用B？析构：先调用A or 先调用B？

#include <iostream>
using namespace std;
class Phone
{
public:
	Phone(string name)
		:m_PhoneName(name)
	{
		cout << "Phone构造" << endl;
	}
	~Phone()
	{
		cout << "Phone析构" << endl;
	}
	string m_PhoneName;
};

class Person
{
public:
	Person(string name, string pName)
		:m_Name(name)
		, m_Phone(pName)
	{
		cout << "Person构造" << endl;
	}
	~Person()
	{
		cout << "Person析构" << endl;
	}
	void playGame()
	{
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 手机" << endl;
	}
	string m_Name;
	Phone m_Phone;

};

int main()
{
	Person p("阿飞", "ipone13");
	p.playGame();
	return 0;
}

我们发现，初始化先调用的是Phone的构造，然后再调用的Person的构造；

销毁先调用的是Person的析构，再调用的是Phone的析构。

这个循序我们可以把Phone比作一个汽车的零件，把Person比作汽车，在组装的时候，肯定要先构造零件，再构造汽车；

在拆掉汽车的时候，要先把汽车拆掉，才能进一步拆除汽车的零件。

6.3静态成员

静态成员包括：

静态成员变量

所有对象共享同一份数据
在编译阶段分配内存
类内生命，类外初始化

静态成员函数

所有对象共享同一个函数
静态成员函数只能访问静态成员变量

类内生命，类外初始化：

class Person
{
public:
	static int m_A; //静态成员变量
private:
	static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;

静态成员函数：

class Person
{
public:
	static void func()
	{
		cout << "func调用" << endl;
		m_A = 100;  //静态成员函数只能访问静态成员变量
	}
private:
	static int m_A; 
	int m_B; 
};

7.C++对象模型和this指针

7.1成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储，只有非静态的成员变量才属于类的对象上。

class Person {
public:
	Person() 
    {
		mA = 0;
	}
	void func() 
    {
		cout << "mA:" << this->mA << endl;
	}
private:
    int mA;
	static int mB; 
};

int main() 
{
    Person p;
	cout << sizeof(p) << endl;//只有非静态的成员变量属于对象，所以输出为4
	return 0;
}

7.2this指针的概念

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会公用同一块代码；

那么问题就是：这一块代码是如何区分是哪个对象调用了自己呢？答：this指针。

this指针指向被调用的成员函数所属的对象，this指针是隐含每一个非静态成员函数的一种指针。

this指针是不需要定义的，可以直接使用。

this指针的两个用途：

当形参和成员变量同名的时候，可以用this指针来区分（这个作用和Java中的this是相同的）
在类的非静态成员函数中返回对象本身，可以使用return *this

class Person
{
public:
	Person(int age)
	{
		//1、当形参和成员变量同名时，可用this指针来区分
		this->age = age;
	}
	Person& PersonAddPerson(Person p)
	{
		this->age += p.age;
		return *this;
	}
	int age;
};
void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
	cout << "p2.age = " << p2.age << endl;
}
int main()
{
	test01();
	return 0;
}

7.3空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是需要注意的是有没有用到this指针；

如果用到this指针，需要加以判断保证代码的健壮性。

//空指针访问成员函数
class Person {
public:

	void ShowClassName() {
		cout << "Person类!" << endl;
	}

	void ShowPerson() {
		if (this == NULL) {
			return;
		}
		cout << mAge << endl;
	}

public:
	int mAge;
};

void test01()
{
	Person * p = NULL;
	p->ShowClassName(); //空指针，可以调用成员函数
	p->ShowPerson();  //但是如果成员函数中用到了this指针，就不可以了
}

int main() {

	test01();
	return 0;
}

成员函数在使用this指针的时候，需要进行检查。

7.4const修饰成员函数

常函数：

成员函数后面加const之后我们称这个函数为常函数
常函数内不可以修改成员属性

常对象：

声明对象前加const称该对象为常对象
常对象只能调用常函数

const对象和函数的使用：

class Person {
public:
	Person() 
    {
		m_A = 0;
		m_B = 0;
	}
	//this指针的本质是一个指针常量，指针的指向不可修改
	//如果想让指针指向的值也不可以修改，需要声明常函数
	void ShowPerson() const 
    {
		//const Type* const pointer;
		//this = NULL; //不能修改指针的指向 Person* const this;
		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的

		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}

	void MyFunc() const 
    {
		//mA = 10000;
	}
public:
	int m_A;
	mutable int m_B; //可修改 可变的
};
//const修饰对象  常对象
void test01() 
{
	const Person person; //常量对象  
	cout << person.m_A << endl;
	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
	person.m_B = 100; //但是常对象可以修改mutable修饰成员变量
	//常对象访问成员函数
	person.MyFunc(); //常对象不能调用const的函数
}

int main() 
{
	test01();
	return 0;
}

类和对象的基础内容到这里就结束了，类和对象是我们学习面向对象语言的重点，像封装、继承、多态都和类和对象有着密不可分的关系；一定要熟练掌握！！！