C++默认函数和类的组合07

C++默认函数和类的组合

                        完成优先于完美

直接上代码：

• 什么类的组合？
• <通过把别人的对象当做自己成员，然后访问“可访问”成员>
  以另一个类的对象为数据成员
• 类的组合：
  • 构造函数的写法，必须采用初始化参数列表的写法

#include"iostream"
#include"string"
using namespace std;
class Boy{
public:
	Boy(string name, int age) :name(name), age(age) { "construction funtion\n"; }
	void print()
	{
		cout << name << " " << age << endl;
	}
protected:
	void pringdata()
	{
		cout << age << '\t' << name<<endl;
	}
	int age;
	string name;
};
class girl {
public:
	// 必须用初始化参数列表
	girl(string boyname, int boyage, string gname) :boy(boyname, boyage) //init combine object
	{
		this->gname = gname;// init own object
	}
	// 可以合并一起写，或下面分开重载；设置默认数据
	girl(string gname) :gname(gname),boy("Bigboy",22) {}
	void print()
	{
		boy.print();
		//boy.printdata();  不可访问，因为boy对于Boy来说类外
		cout << gname << endl;

	}
protected:
	string gname;
	Boy boy;// only can create a none argument object
};
int main()
{
	Boy b("YY",21);
	b.print();
	girl G("boy",19,"G");
	G.print();
	girl g = { "ff" };
	g.print();

	
	return 0;
}

类的组合构造顺序问题:

• 构造顺序只和定义对象顺序的有关，和初始化参数列表无参

#include"iostream"
#include"string"
using namespace std;
class A {
public:
	A(string aa) :a(aa) { cout << a << endl; }
protected:
	string a;
};
class B{
public:
	B(string bb) :b(bb) { cout << b << endl; }
protected:
	string b;
};
class C {
public:
	C(string cc) :c(cc) { cout << c << endl; }
protected:
	string c;
};
class D {
public:
	D(string a,string b,string c) :a(a),b(b),c(c) { cout << 'D' << endl; }
protected:
	A a;
	B b;
	C c;
};
int main() {

	D d("A", "B", "C");
	return 0;
}

类中类

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

#include<iostream>
#include<string>
using namespace std;
struct Node 
{
	int data;
	Node* next;
};
class List {
public:
protected:
	Node* headnode;//看做数据
private:
	class iterator {
	public:

	protected:
    // 类中类
	};

};
int main()
{
	List::iterator iter;// 不可访问
	return 0;
}

private ----> public is OK；
迭代器：类模仿指针行为
可以用类中类来 遍历链表

#include <iostream>
using namespace std;
struct Node 
{
	int data;
	Node* next;
	Node()
	{
		this->next = nullptr;
	}
	Node(int data) 
	{
		this->next = nullptr;
		this->data = data;
	}
};
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=(Node* pMove) 
		{
			this->pMove = pMove;
		}
		bool operator!=(Node* pMove) 
		{
			return this->pMove != pMove;
		}
		iterator operator++()
		{
			pMove = pMove->next;
			return iterator(pMove);
		}
		Node*& operator*() 
		{
			return pMove;
		}
	protected:
		Node* pMove;
	};
	Node* begin()
	{
		return headNode->next;
	}
	Node* end() 
	{
		return nullptr;
	}
};
//类中枚举类型
class  A 
{
public:
	enum time {first,second};
protected:
	enum date {mon,sur,tus};
	//类中的枚举类型受权限限定
};

int main() 
{
	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;
	}
	//cout << A::date::mon << endl; 不可访问
	cout << A::time::first << endl;
	return 0;
}

C++类中默认的函数

• 默认构造函数
• 默认拷贝构造函数
• 默认析构函数
• 默认赋值运算

#include <iostream>
using namespace std;
class A
{
public:
	A() = default;  //调出默认函数
	A(A& object) = default;  //默认拷贝构造函数 对对object引用
	//void print() = default;  它 普通函数不存在默认函数
	A& operator=(A& object) = default;  // 等号赋值运算也是有默认函数
	~A() = default;
};
int main()
{
	A a;
	A b = a;
	A c;
	c = a;
	return 0;
}

总结

迭代器：类模仿指针行为
可以用类中类来 遍历链表