C++ 基础【08】

本文代码仓库地址： gitee码云CSDN笔记仓库地址

---

---

成员变量和成员函数【Class07】

// C++对象模型和this指针 -- 成员变量和成员函数
#include <iostream>

using namespace std;


class person01_xy {
	// 空对象默认会分配一个字节
};

class person02_xy {
public:
	// 不属于类的对象上【不会计入内存】
	// 非静态成员变量 属于类的对象上
	int a;
	// 非静态成员变量 不属于类队形上
	static int b;
	// 非静态成员函数 不属于类对象上
	void pFun01() {}
	// 静态成员函数 不属于类的对象上
	static void Pfun02() {}
};


// 空对象所占内存大小
void fun01() {
	// C++编译器会给每个空对象分配一个字节空间，以便区分空对象占内存的位置【都会有属于自己的地址】
	person01_xy p1;
	cout << "空的 person01_xy 所占字节 sizeof(p1) = " << sizeof(p1) << endl;
}

// 非空对象所占内存大小
void fun02() {
	person02_xy p1;
	cout << "空的 person02_xy 所占字节 sizeof(p1) = " << sizeof(p1) << endl;
}


int main() {

	fun01();
	fun02();
	

	cout << endl;
	system("pause");
	return 0;
}

---

this指针的使用【Class08】

// C++对象模型和this指针 -- this指针的使用
#include <iostream>

using namespace std;


// 不使用this的情况，类中声明和变量名和函数中的临时变量名想同时【就近原则】
class person01_xy {
public:
	int a = 0;

	person01_xy() {
		cout << "01--person01_xy类中的默认构造函数中打印 a = " << a << endl;
	}

	// 函数里面的 a 都是同一个 a【传过来的参数】，就修改的不是类中成员变量
	void pFun01(int a) {
		a = a;
	}

	~person01_xy() {
		cout << "04--person01_xy类中的析构函数中打印 a = " << a << endl;
	}
};

// 使用this的情况
class person02_xy {
public:
	int a = 0;

	person02_xy() {
		cout << "01--person02_xy类中的默认构造函数中打印 a = " << a << endl;
	}

	// 使用this指向的就是当前调用它的对象
	void pFun01(int a) {
		this->a = a;
	}

	// 返回对象本身用 *this，可以往后面无限累加
	person02_xy& pFun02(person02_xy m_p) {
		a = a + m_p.a;
		cout << "pFun02--这里 a 进行了一次叠加" << endl;
		return *this;
	}

	// 类型后面不加 & 返回的就是拷贝的数据，不是数据本身,不能进行多重叠加
	person02_xy pFun03(person02_xy m_p) {
		a = a + m_p.a;
		cout << "pFun03--这里 a 进行了一次叠加" << endl;
		return *this;
	}

	void pFun() {
		cout << "在类中打印的 a = " << a << endl;
	}

	~person02_xy() {
		cout << "04--person02_xy类中的析构函数中打印 a = " << a << endl;
	}
};


// 函数里面没有使用 this 的情况
void fun01() {
	person01_xy p1;
	p1.pFun01(10);
	cout << "函数 fun01 中打印的p1 = " << p1.a << endl;
}

// 函数里面使用了 this 的情况
void fun02() {
	person02_xy p1;
	p1.pFun01(20);
	cout << "函数 fun02 中打印的p1 = " << p1.a << endl;
}

// 函数里面没有使用了 this【链式编程】
void fun03() {
	person02_xy p1;
	p1.pFun01(11);
	person02_xy p2;
	// 【拷贝构造函数】这个地方会调用很多次析构函数，其中有4次不理解，后期需要回头看看----------
	// 大胆猜测一下，是因为这个是返回拷贝的值，所以会比下面的多出来4次析构，下面返回的是相同的值
	p2.pFun03(p1).pFun03(p1).pFun03(p1).pFun03(p1);
	cout << "函数 fun03 中打印的p1 = " << p2.a << endl;
}

// 函数里面使用了 this【链式编程】
void fun04() {
	person02_xy p1;
	p1.pFun01(22);
	person02_xy p2;
	// 这个地方就没有那些不理解的析构函数
	p2.pFun02(p1).pFun02(p1).pFun02(p1);
	cout << "函数 fun04 中打印的p1 = " << p2.a << endl;
}


int main() {

	fun01();
	cout << "------------------分界线------------------" << endl;
	fun02();
	// 还有一种解决的方法就是起不一样的变量名
	cout << "------------------分界线------------------" << endl;
	fun03();
	cout << "------------------分界线------------------" << endl;
	fun04();


	cout << endl;
	system("pause");
	return 0;
}

---

空指针调用成员函数【Class09】

// C++对象模型和this指针 -- 空指针调用成员函数
#include <iostream>

using namespace std;


class person01_xy {
public:
	int age = 0;

	void pFun01() {
		cout << "这是 person01_xy 类" << endl;
	}

	void pFun02() {
		// 为了程序的健壮性需要加一个判断，不让空指针去访问下面需要指针访问的操作
		if (this == NULL)
		{
			cout << "指针为空，退出这个函数啦！" << endl;
			return;
		}
		// 下面的age是简写，写全是【this->age】
		cout << "这是 person01_xy 类" << age << endl;
	}

	~person01_xy(){
		cout << "这是 person01_xy 类的析构函数" << endl;
	}
};


void fun01() {
	person01_xy* p1 = NULL;
	// 空指针也是可以调用成员函数的
	p1->pFun01();
	// 下面空指针访问上面的 pFun02 函数是可行的，但是用空指针去访问age，就是不行的了
	p1->pFun02();
}



int main() {

	fun01();
	cout << "------------------分界线------------------" << endl;


	cout << endl;
	system("pause");
	return 0;
}

---

const修饰成员函数【Class10】

// C++对象模型和this指针 -- const修饰成员函数
#include <iostream>

using namespace std;


class person01_xy {
public:
	int a = 0;
	// 这是一个特殊的变量，在常函数中也可以修改这个值，因为声明 b 时前面加了 mutable
	mutable int b = 0;

	// 普通函数
	void pFun01() {
		/*
		* 这里的 a 本质是 this->a
		* 其中 this 的本质是属于指针常量，类似于 int* const this;
		*/
		a = 111;
		b = 111;
	}

	// 常函数
	void pFun02() const {
		/*
		* 常函数中不能修改普通的函数
		* 这里的 a 本质是 this->a
		* 其中 this 的本质是属于常量指针常量，类似于 const int* const this;
		*/
		// a = 222;
		b = 222;
	}

};


void fun01() {
	person01_xy p1;
	p1.a = 1;
	p1.b = 1;
	cout << "p1直接修改a和b后的a = " << p1.a << "\t b = " << p1.b << endl;
	p1.pFun01();
	cout << "p1调用pFun01后的a = " << p1.a << "\t b = " << p1.b << endl;
	p1.pFun02();
	cout << "p1调用pFun02后的a = " << p1.a << "\t b = " << p1.b << endl;
}

void fun02() {
	// 常对象
	const person01_xy p2;
	// 常对象只能调用常函数，不能调用普通函数
	// p2.pFun01();
	p2.pFun02();
	cout << "p1调用pFun02后的a = " << p2.a << "\t b = " << p2.b << endl;
	// 常对象不允许修改普通的变量，原因可以看 pFun02 的注释
	// p2.a = 333;
	// 变量前面加了 mutable 的在常对象中也可以修改
	p2.b = 333;
	cout << "p1直接修改a和b后的a = " << p2.a << "\t b = " << p2.b << endl;
}


int main() {

	fun01();
	cout << "------------------分界线------------------" << endl;
	fun02();

	cout << endl;
	system("pause");
	return 0;
}

---

一点点笔记，以便以后翻阅。