【C++核心编程 4】——类和对象——4.2 对象的初始化和清理[ 4.2.6-8 初始化列表 / 对象成员 / 静态成员 ]

4.类和对象

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

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

具有相同性质的对象，可以抽象为类

4.2.6 初始化列表

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

语法：构造函数():属性1(值1),属性2(值2)...{}

示例：

#include<iostream>
using namespace std;
class Person {
public:
  	//传统初始化操作
	//Person(int a, int b, int c){
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}
  
  //初始化列表初始化属性
	Person() :m_A(10), m_B(20), m_C(30) {
		cout << "Person的无参构造函数" << endl;
	}
	Person(int a, int b, int c) :m_A(a),m_B(b),m_C(c) {
		cout << "Person的有参构造函数" << endl;
	}
	~Person() {
		cout << "Person的析构函数" << endl;
	}
	int m_A;
	int m_B;
	int m_C;

};
void test01() {
	Person p1;
	cout << "p1.m_A=" << p1.m_A << "p1.m_B=" << p1.m_B << "p1.m_C=" << p1.m_C << endl;
	Person p2(22, 33, 44);
	cout << "p2.m_A=" << p2.m_A << "p2.m_B=" << p2.m_B << "p2.m_C=" << p2.m_C << endl;

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

4.2.7 类对象作为类成员 （对象成员）

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

例如：

class A{}
class B{
  A a;
}

B类中有对象A作为成员，A为对象成员

那么，当创建B对象时，A与B的构造和析构的顺序是谁先谁后呢？

当其他类对象作为本类成员，构造时先构造类对象，再构造自身

析构的顺序与构造相反

即先构造A对象a，再构造B

析构，先析构B，再析构A

示例

#include<iostream>
#include<string>
using namespace std;
class Phone {
public:
	Phone(string p_name):phoneName(p_name) {
		cout << "Phone的有参构造函数" << endl;
	}
	~Phone() {
		cout << "Phone的析构函数" << endl;
	}
	string phoneName;
};
class Person {
public:
	//Phone p_phone=phoneName 隐式转换法
	Person(string name, string phoneName) :p_name(name),p_phone(phoneName) {
		cout << "Person的有参构造函数" << endl;
	}
	~Person() {
		cout << "Person的析构函数" << endl;
	}
	string p_name;
	Phone p_phone;
};
//当其他类对象作为本类成员，构造时先构造类对象，再构造自身
//析构的顺序与构造相反
void test01() {
	Person p("张三", "小米");
	cout << p.p_name <<"的手机是" << p.p_phone.phoneName << "手机"<<endl;
  //注意：p.p_phone.phoneName，需要调到该对象下的属性，否则报错
}
int main() {
	test01();
	return 0;
}

4.2.8 静态成员

静态成员，就是 在成员变量和成员函数前 假设关键字static，成为静态成员

静态成员分为：

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

示例一：静态成员变量

#include<iostream>
using namespace std;
class Person {
public:
	//1.所有对象共享同一份数据
	//2.在编译阶段分配内存
	//3.类内声明，类外初始化
	static int a;

	//静态成员变量也是有访问权限的
private:
	static int b;
};
//类外初始化
int Person:: a = 100;

void test01() {
	Person p;
	cout <<"p.a"<<p.a << endl;//100

	Person p2;
	p2.a = 200;
	cout << "p.a" << p.a << endl;//200
	//共享同一份数据
}

void test02() {
	//静态成员变量，不属于某个对象上，所有对象都共享同一份数据
	//因此，静态成员变量有两种访问方式：
	// 1. 通过对象进行访问  
	Person p;
	cout << p.a << endl;
	//2.通过类名进行访问
	cout << Person::a << endl;

	//cout<< Person::b << endl;此行代码错误，类外访问不到私有的静态成员变量
}
int main() {
	test01();
	test02();
	return 0;
}

静态成员变量有两种访问方式：1.通过对象进行访问 2.通过类名进行访问

静态成员变量有访问权限，类外无法访问私有的静态成员变量

示例二：静态成员函数

#include<iostream>
using namespace std;

//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量
class Person {
public:
	static void func() {
		cout << "static void func调用" << endl;
		m_a = 100;//静态成员函数可以访问 静态成员变量
		//m_b = 200;静态成员函数 不可以访问 非静态成员变量，因为无法区分该变量是哪个对象的
	}
	static int m_a;//静态成员变量
	int m_b;
private:
	static void func2() {
		cout << "private static void func调用" << endl;
	}
};
//静态成员变量初始化
int Person::m_a = 0;

void test01() {
	//静态成员函数访问有两种方式：
	//1.通过对象进行访问
	Person p;
	p.func();
	//2.通过类进行访问
	Person::func();
	cout << Person::m_a<< endl;//100
	
	//Person::func2();类外访问不到私有的静态成员函数
}
int main() {
	test01();
	return 0;
}

一、静态成员函数访问方式有两种：1.通过对象进行访问 2.通过类进行访问

二、静态成员函数 不可以访问 非静态成员变量 因为无法区分该变量是哪个对象的

三、私有的静态成员函数 在类外无法访问