一、以另一个类的对象作为数据成员，构造函数必须采用初始化参数列表的方式

构造函数必须采用初始化参数列表的方式

访问依旧受到权限限定

class Boy
{
public:
	Boy(string name, int age) :name(name), age(age) {}
	void print()
	{
		cout << name << "\t" << age<<endl;
	}
protected:
	void printData()
	{
		cout << name << "\t" << age << endl;
	}
	string name;
	int age;

};
class MM
{
public:
	//对于boy用初始化参数列表的方式，对于自己的mmName随意
	MM(string boyName, int boyAge,string name) :boy(boyName, boyAge),mmName(name) {}
	MM(string mmName) :mmName(mmName), boy("默认", 15) {}
	void print()
	{
		boy.print();
		//不能调用printData访问权限还是相同的,依旧受权限限定
	}
protected:
	string mmName;
	Boy boy;//只存在构造一个对象的写法，不能够在此初始化
    //Boy boy("默认"，18) 错误
};

构造顺序问题（只和定义顺序有关）

class A
{
public:
	A(string str) :str(str) {
		cout << str;
	};
	string str;
};
class B
{
public:
	B(string str) :str(str) {
		cout << str;
	}
	string str;
};
class C
{
public:
	C(string str) :str(str) {
		cout << str;
	}
	string str;
};
class D
{
public:
	D(string stra, string strb, string strc) :a(stra), c(strc),b(strb) {}
//构造顺序只和定义顺序有关
	A a;
	B b;
	C c;
};

二、类中类

迭代器-->类模仿指针 本质类中类

以链表为例

    List list;
	for (int i = 0;i < 3;i++)
	{
		list.push_front(i);
	}
    //采用重载的方式，将对象用作访问的接口
	List::iterator iter;
	for (iter = list.begin();iter != list.end();iter++)
		cout << (*iter)->data;

struct Node
{
	int data;
	Node* next;
	Node()
	{
		this->next = nullptr;
	}
	Node(int data)
	{
		this->data = data;
		this->next = nullptr;
	}
};
class List
{
public:
	List()
	{
		headNode = new Node;
	}
	void push_front(int data)
	{
		Node* newNode = new Node(data);
		newNode->next = headNode->next;
		headNode->next = newNode;
	}
	
protected:
	Node* headNode;
public:
	class iterator
	{
	public:
		iterator(Node* pMove = nullptr) :pMove(pMove) {}
		void operator=(iterator object)
		{
			this->pMove = object.pMove;
		}
		bool operator!=(iterator object)
		{
			return this->pMove != object.pMove;
		}
		 iterator operator++(int)//用int表示后置++，int用作标识
		{
			pMove = pMove->next;
			return iterator(pMove);
		}
		 Node* operator*()
		 {
			 return pMove;
		 }
	protected:
		Node* pMove;
	};
	iterator begin()
	{
		return iterator(headNode->next);
	}
	iterator end()
	{
		return iterator(nullptr);
	}
};

类中的枚举类型依旧受到权限限定

class A
{
public:
	enum sa{ed,ad,cx};
protected:
	enum data{man,sxc};
};
int main()
{
    //cout << A::data::man; 错误
	cout << A::sa::ad;
	
	return 0;
}

三、默认的函数

class A
{
public:
	A() = default;//类中默认的构造函数
	A(A& object) = default;//默认的拷贝构造函数
	A& operator=(A& object) = default;//默认赋值
	~A() = default;//默认的析构函数
	
};