C++类的组合

 以另一个类的对象为数据成员

构造函数的写法，必须采用初始化参数列表的写法

类的组合构造顺序问题：

类的组合析构问题：

#include<iostream>
#include<string>
using namespace std;
class Girl {
public:
	Girl(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 Boy {
public:
	//不仅要对自己的数据成员初始化，还要对组合类的数据成员初始化，且必须采用初始化参数列表
	//对于自己的属性想用什么方式就用什么方式初始化
	Boy(string mmname, int mmage, string bbname) :girl(mmname, mmage) /*调用Girl类构造函数所以必须一致*/ {
		this->bbname = bbname;//优先构造组合类对象顺序0
	}
	Boy(string bbname):bbname(bbname),girl("默认",18) {}
	void print() {
		girl.print();
		//girl.printData();不可访问,boy对于Boy是类外
		cout << bbname << endl;
	}
protected:
	string bbname;
	Girl girl;//没有这种写法Girl girl("男孩",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), b(strb), c(strc) {
		cout << "D" << endl;
	}
	A a;
	B b;
	C c;
};

int main() {
	Girl mm("美女", 18);
	Boy gg("帅哥");
	gg.print();
	Boy gg1("美女", 20, "帅哥1");
	gg1.print();

	D d("a", "b", "c");

	return 0;
}

类中类

依旧受权限限定，访问方式需要类名限定

#include<iostream>
using namespace std;

struct Node
{
	int data;
	Node* pNext;
	Node() {
		this->pNext = nullptr;
	}
	Node(int data) {
		this->data = data;
		this->pNext = nullptr;
	}
};
class List {
public:
	List() {
		headNode = new Node;
	}
	void insert_front(int data) {
		Node* newNode = new Node(data);
		newNode->pNext = headNode->pNext;
		headNode->pNext = newNode;

	}
protected:
	Node* headNode;
private:
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) {
			pMove = pMove->pNext;
			return iterator(pMove);
		}
		Node* operator*() {
			return pMove;
		}

	protected:
		struct Node* pMove;//c++struct可以省略
		
	};
	iterator begin() {
		return iterator(headNode->pNext);//匿名对象
	}
	iterator end() {
		return iterator(nullptr);
	}
};
//类中的枚举类型
class A {
public:
	enum time{four,five,six};
protected:
	enum data{one,two,three};
	//类中的枚举类型也受权限限定
};

int main() {
	List list;
	for (int i = 0; i < 3; i++) {
		list.insert_front(i);
	}
	List::iterator iter;
	for (iter = list.begin(); iter != list.end(); iter++) {
		cout << (*iter)->data;
	}
	//cout<<A::data::mon<<endl;
	cout << A::time::five<< endl;
	return 0;
}

C++中默认的函数

默认构造函数

默认拷贝函数

默认析构函数

默认的复制运算符

#include<iostream>
using namespace std;

class A {
public:
	A() = default;
	A(A& object) = default;
	~A() = default;
	A& operator=(A& object) = default;
protected:
};
int main() {
	A a;
	A b = a;


	return 0;
}