C++类和对象

C++面向对象的三大特性为：封装、继承、多态

C++认为万事万物都皆为对象，对象上有其属性和行为。

具有相同性质的对象，可以抽象为类，人属于人类，车属于车类。

封装

封装是C++面向对象三大特性之一。

封装的意义：

• 将属性和行为作为一个整体，表示生活中的事物。
• 将属性和行为加以权限控制。

实例化：通过一个类创建一个对象

类中的属性和行为，统一称为成员。
属性——成员属性、成员变量
行为——成员函数、成员方法

封装意义二

类在设计时，可以把属性和行为放在不同的权限下，加以控制。
访问权限有三种：

1. public：公共权限——类内、类外可以访问
2. protected：保护权限——类内可以访问，类外不可以访问，子类可以访问
3. private：私有权限——类内可以访问，类外不可以访问，子类不可以访问

struct和class区别

在C++中，struct和class唯一区别就是默认的访问权限不同。

区别：

• struct：默认权限为公共
• class：默认权限为私有

成员属性设置为私有

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

#pragma once 防止头文件重复包含

对象的初始化和清理

生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用的时候也会删除一些自己信息数据保证安全。

C++的面向对象来源于生活，每个对象都会有初始化设置，以及对象销毁前的清理数据的设置。

构造函数和析构函数

对象的初始化和清理是两个非常重要的问题。

一个对象或变量没有初始状态，对其使用后果未知。
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题。

C++利用构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制我们要做的事情，因此我们如果不提供构造和析构，编译器会提供空实现的构造函数和析构函数。

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名(){}

1. 构造函数。没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次

析构函数语法：~类名(){}

1. 析构函数，没有返回值也不写void
2. 函数名称与类名相同，在名称前加上符号~
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前自动调用析构，无须手动调用，而且只会调用一次

构造函数的分类及调用

两种分类方式：

• 按参数分为：有参构造和无参构造
• 按类型分为：普通构造和拷贝构造

三种调用方式：

• 括号法
• 显示法
• 隐式转换法

调用默认构造函数时候，不要加()

Person p1();
返回类型 函数名 ();会认为是一个函数声明，main函数内允许函数声明

Person(10); //匿名对象，当前执行结束后，系统会立即回收掉匿名对象

拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况：

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

构造函数调用规则

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

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数，对属性进行值拷贝

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

深拷贝与浅拷贝

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

浅拷贝的问题就是堆区的内存重复释放。

浅拷贝的问题，要利用深拷贝进行解决。

编译器自己提供的就是浅拷贝，因此要自己实现拷贝构造函数

class Person{

public:
	Person(const Person& p2){
		this->age = p2.age;//浅拷贝
		this->height = new int(*p2.height); //深拷贝
	}

	~Person(){
		if(this->height != nullptr){
			delete height;
			height = NULL;
		}
	}

private:
	int age;
	int *height;
};

如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。

初始化列表

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

class Person{
public:
	Person(string name, string pName):m_name(name),m_phone(pName){
		
	}

	string m_name;
	Phone m_phone;
};

当其它类对象作为本类成员，构造时候先构造类对象，再构造自身。
析构的顺序与构造相反。

静态成员

类中的函数或者属性都称为成员。
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。

静态成员分为：

• 静态成员变量：所有对象共享同一份数据，在编译阶段分配内存，类内声明，类外初始化。
• 静态成员函数：所有对象共享同一个函数。静态成员函数只能访问静态成员变量。

静态成员变量，不属于某个对象上，所有对象都共享同一份数据。

void test02() {
	//因此静态成员变量有两种访问方式
	//1、通过对象进行访问
	//2、通过类名进行访问
	//Person p;
	//cout << p.age << endl;

	cout << Person::age << endl;
}

类外访问不到私有成员。

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

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

空对象占用1个字节
C++编译器会给每个空对象分配一个字节空间，是为了区分空对象占用内存的位置。

每个空对象也应该有一个独一无二的内存地址。

class Person {
	int m_A;
};

只有非静态成员变量属于类的对象上。

this指针概念

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

问题是，这一块代码是如何区分哪个对象调用自己的呢？
C++通过特殊的对象指针，this指针，解决上述问题，this指针指向被调用的成员函数所属的对象。

this指针是隐含在每一个非静态成员函数内的一种指针。

当形参和成员变量同名时，可以用this指针来区分。
在类的非静态成员函数中返回对象本身，可使用retrun *this。

空指针访问成员函数

#include<iostream>
using namespace std;

class Person {

public:
	void showClassName() {
		cout << "Person Class" << endl;
	}
	void showAge() {
		if (this == nullptr) {
			return;
		}
		cout << "age = " << this->m_Age;
	}
	int m_Age;
};



int main() {
	Person* p = NULL;
	p->showClassName();
	p->showAge();
	system("pause");
	return 0;
}

const修改成员函数

成员函数加const后我们称这个函数为常函数。
常函数不可以修改成员属性。
成员属性声明加关键字mutable后，在常函数中仍然可以修改。

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

this指针，本质上是指针常量，指针的指向不可以修改：Person * const this;

在成员函数后面加const，修饰的是this指针，让指针指向的值也不可以修改。

友元

生活中家里的客厅（Public），卧室（Private），客厅里所有来的客人都可以进去，但是卧室是私有的，只有你能进去，但是，也可以允许好朋友进去。

在程序里，有些私有属性，也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术。

友元的目的就是让一个函数或者类，访问另一个类中私有成员。

友元的关键字为friend。

友元的三种实现方式：

• 全局函数做友元
• 类做友元
• 成员函数做友元

class Building{
	//goodGay全局函数是Building好朋友，可以访问Building中私有成员
	friend void goodGay(Building b);
}

#include<iostream>
using namespace std;

class Building {
	friend class GoodGay;
public:
	Building();
	string m_SittingRoom;
private:
	string m_BedRoom;
};
class GoodGay {
public:
	GoodGay();
	void visit();
	Building* building;
};

Building::Building() {
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

GoodGay::GoodGay() {
	building = new Building;
}

void GoodGay::visit() {
	cout << building->m_SittingRoom << endl;
	cout << building->m_BedRoom << endl;
}
int main() {
	GoodGay gg;
	gg.visit();
	system("pause");
	return 0;
}

运算符重载

对于内置数据类型，编译器知道如何进行运算。