C++学习日记---第15天（蓝桥杯备赛---语法复习阶段）

笔记复习

1.初始化列表

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

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

初始化列表就相当于函数的形参初始化

下面我们对比一下传统的构造函数和初始化列表的构造函数

传统构造函数：

person(int a, int b, int c) {
	m_A=a;
	m_B=b;
	m_C=c;
}

使用初始化列表来初始属性：

person(int a,int b,int c) :m_A(a), m_B(b), m_C(c) {

}

完整代码如下：

#include<iostream>
using namespace std;

class person {
public:
	person(int a,int b,int c) :m_A(a), m_B(b), m_C(c) {

	}
private:
	int m_A;
	int m_B;
	int m_C;
};

void test01() {
	person p(30,20,10);
	cout << "m_A=" << p.m_A << endl;
	cout << "m_B=" << p.m_B << endl;
	cout << "m_C=" << p.m_C << endl;
}

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

2.类对象作为类成员

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

就像结构体中结构体a的对象可以包含结构体b一样

例如：

class A {}//A类的一个定义
class B{
    A a;
   }

 这里B类中有A的对象a作为成员

前面我们知道，C++中构造函数随对象的创建而被调用，析构函数随对象的销毁而被调用，那么在这里当我们调用a时，是先调用B的构造函数还是先调用A的构造函数，析构函数呢？下面我们写一个测试代码测试一下

测试代码：人拿着手机

显然根据逻辑，应该是在人的类中创建手机类的对象，由前面的嵌套结构体知识可知，这里我们要把手机类的定义写在人类的定义前面，代码如下：

class Phone {
public:
	Phone(string pName) {
		m_PName = pName;
		cout << "phone的构造函数调用" << endl;
	}
	~Phone() {
		cout << "phone的析构函数调用" << endl;
	}
	string m_PName;
};

class person {
public:
	person(string name, string pName):m_Name(name),m_Phone(pName) {
		cout << "person的构造函数调用" << endl;
	}
	~person() {
		cout << "person的析构函数调用" << endl;
	}
	string m_Name;
	Phone m_Phone;
};

ps：这里为了方便没有把属性设置为私有，否则我们要写set，get函数

下面我们调用一下m_phone，结果如下：

 由此我们可以得出一个规律，若本类的成员是其他类的对象，那么当我们调用这个对象时，会先调用其他对应类的构造函数，再调用本类的构造函数，析构函数调用的顺序则相反。

3.静态成员

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

静态成员分为静态成员变量和静态成员函数

1）静态成员变量

特点：

1.所有对象共享同一份数据

2.类内声明，类外初始化

对于第二点的解释：因为静态成员变量共享同一份数据，那么就不能在类中，否则会被某个对象所拥有，而该对象拥有这个静态成员变量变量后其他对象就无法使用了，与第一点矛盾

（静态变量尽管是在类外初始化，但私有静态成员变量类外仍然是无法访问的）

静态成员变量在类内声明的语法：

static int m_A;

 静态成员变量在类外初始化的语法：

int person::m_A = 100;

静态成员变量有两种访问方式：

a.通过对象进行访问

person p;
cout << p.m_A << endl;

 b.通过类名进行访问

cout << person::m_A << endl;
//::表示m_A这个成员在person类的作用域中

 完整代码如下：

#include<iostream>
using namespace std;

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

int person::m_A = 100;
int person::m_B = 200;

void test01() {
	//1.通过对象进行访问
	person p;
	cout << p.m_A << endl;
    p.m_A=200;
    cout<<p.m_A<<endl;
	//2.通过类名进行访问
	cout << person::m_A << endl;
	cout << person::m_B << endl;//类外访问不到私有静态成员变量
}

int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

2）静态成员函数

特点：

1.所有对象共享同一个函数

2.静态成员函数只能访问静态成员变量

（与静态成员变量相同，静态成员函数也是有访问权限的）

#include<iostream>
using namespace std;

class person {
public:
	static void func() {
		m_A = 100;//静态成员函数可以访问静态成员变量
		m_B = 200;//静态成员函数无法访问非静态成员变量
		cout << "静态成员函数的调用" << endl;

	}
	static int m_A;//静态成员变量
	int m_B;
	//静态成员函数也是有访问权限的
private:
	static void func2() {
		cout << "私有静态成员函数的调用" << endl;
	}
};



void test01() {
	//1.通过对象进行访问
	person p;
	p.func();
	//2.通过类名进行访问
	person::func();
	person::func2();
}

int main() {
	test01();
	system("pause");
	return 0;
}