C++ 类和对象（三）初始化列表，类作为对象成员和静态成员

C++ 类和对象（三） 初始化列表，类作为对象成员和静态成员

1. 初始化列表

作用：

C++提供初始化列表语法，来初始化属性
类似构造函数也是提供初始化属性的作用一样

语法：

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

注意：

冒号的位置在构造函数的形参列表的后面，然后写属性，赋初值，属性，赋初值

示例：

	//有参构造函数
    //Person(int age, string name)
    //{
    //  m_age = age;
    //  m_name = name;
    //  cout << "调用有参构造函数" << endl;
    //}
    //列表初始化
    Person(int age, string name) : m_age(age), m_name(name)
    {
        cout << "列表初始化" << endl;
    }

2. 类作为对象成员

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

class A{}
class B
{
    A a;
}

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

class Phone {
public:
    Phone(string brand): m_brand(brand) {
        cout << "调用Phone 的构造函数" << endl;
    }
    ~Phone() {
        cout << "调用Phone的析构函数" << endl;
    }
    string m_brand;
};

class Person {
public:
    //Phone m_brand = brand; //隐式转换法来初始化对象
    Person(string brand, int age, string  name) : m_p(brand), m_age(age), m_name(name) {
        cout << "调用Person的构造函数" << endl;
    }
    ~Person() {
        cout << "调用Person析构函数" << endl;
    }
    Phone m_p;
    int m_age;
    string m_name;
};
void func()
{
    Person p("apple", 18, "Jerry");
    cout << p.m_name << "is " << p.m_age << ", have a " << p.m_p.m_brand << endl;
}

3. 静态成员

静态成员就是再成员变量和成员函数前加上关键字 static， 成为静态成员

静态成员分为：

• 静态成员变量

1. 所有对象共享同一份数据
2. 在编译阶段分配内存
3. 类内声明， 类外初始化

• 静态成员函数

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

1. 静态成员变量

class Person {
public:
	//1. 类内声明， 类外初始化
	 static int m_a;
};
int Person::m_a = 100;

void func()
{
	Person p;
	p.m_a = 100;
	cout << p.m_a << endl;
	//2. 所有对象访问的是用一个数据
	Person p1;
	p1.m_a = 200;
	cout << p.m_a << endl;
}

静态成员的访问方式:
• 通过对象进行访问
• 通过类名进行访问

void func1()
{
	//静态成员变量不属于某一个对象，所有对象共享同一份数据
	//所以静态成员变量的访问方式有： 
	//1. 通过对象进行访问
	//2. 通过类进行访问
	Person p;
	cout << p.m_a << endl;
	cout << Person::m_a << endl;
}

同其他成员变量一样，静态成员也是有访问权限的。

2. 静态成员函数

两种访问方式：
• 通过对象
• 通过类名

void func()
{
	//两种调用方式：
	//1. 通过对象
	Person p;
	p.test();
	//2. 通过类名
	Person::test();
}

静态成员函数访问静态成员变量，
但不可以访问非静态成员变量，因为它不知道该变量是属于哪个对象的成员的

class Person {
public:
	static void test() {
		m_a = 100; //静态成员函数可以访问静态成员变量
		//m_b = 100; //报错， 不能访问非静态成员变量， 以为不知道是哪个对象的成员
		cout << "调用静态成员函数" << endl;
	};

	static int m_a;
	int m_b;
};

int  Person::m_a = 10;