1:  打印结果？
class A
{
	int a;
public:
	A(int aa)
	{
		a = aa;
		std::cout<<"父构"<<a;
	}
	~A()
	{
		std::cout<<"父析"<<a;
	}
};
class B : public A
{
	int b;
public:
	B(int bb) : A(bb)
	{
		b = bb;
		std::cout<<"子构"<<b;
	}
	~B()
	{
		std::cout<<"子析"<<b;
	}
};
A a1(1);//1)父构1
void f()
{
	static A a2(2);//3)父构2
	B b3(3);//4)父构3,子构3	  子析3,父析3  	//5)父构3,子构3	    子析3,父析3
}
void main()
{
	B* a4 = new B(4);//2)父构4,子构4
	f();
	f();
	delete a4;//6)子析4,父析4  
}
//7) 父析2 
//8) 父析1



2：----------------------------------------------------------------------
class Base
{
public:
	static int count;//功能：记录所有Moster对象和Hero对象的个数,但是不记录Base对象的个数！！
	Base();//1)完成代码，写在类外面
};
int Base::count = 0;
Base::Base()
{
	
}


class Moster : public Base
{
	int hp;//怪生命
public:
	static int count;//功能：记录所有Moster的个数,(要显示定义)
	Moster(int hp);//2)完成代码，写在类外面
};
int Moster::count = 0 ;
Moster::Moster(int hp)//2)完成代码，写在类外面
{
	this->hp = hp;
	count++;//可以统计Moster的个数
	Base::count++;
}

class Hero :public Base
{
	char name[32];//英雄名字
public:
	static int count;//功能：记录所有Hero的个数,(要显示定义)
	Hero(const char* s);//3)完成代码，写在类外面
};
int Hero::count = 0;
Hero::Hero(const char* s)
{
	strcpy(name, s);
	count++;//可以统计Hero的个数
	Base::count++;
}


void main()
{
	//创建了很多对象
	Base a;
	new Base;
	Moster b1(100);
	Moster b2(200);
	Moster* p = new Moster(300);
	Hero h1("abc");
	new Hero("def");
	

	std::cout<<"Moster和Hero对象的总数是："<< __Base::count___或  a.count_____ ;//三种方法
	std::cout<<"Moster和Hero对象的总数是："<< b1.Base::count______ ;
	std::cout<<"Moster和Hero对象的总数是："<< h1.Base::count______ ;

	std::cout<<"Moster对象的总数是："<< __Moster::count________ ;//两种方法
	std::cout<<"Moster对象的总数是："<< ___b1.count_______ ;

	std::cout<<"Hero对象的总数是："<< __Hero::count________ ;//两种方法
	std::cout<<"Hero对象的总数是："<< ____h1.count______ ;
}

3:----------------------------------------------------------------------
class A
{
public:
protected:
private:
};
关于访问权限：填写可以访问还是不可访问
_____________________________________________________________________
|			 |public成员	 |protected成员		 |private成员		|
|------------|---------------|-------------------|------------------|
|类里面		 |		1	可以 |		2可以		 |		3可以		|
|------------|---------------|-------------------|------------------|
|类外面		 |		4	可以 |		5不可以		 |		6不可以		|
|____________|_______________|___________________|__________________|

4:----------------------------------------------------------------------
class B1 : public A
{};
class B2 : protected A
{};
class B3 : private A
{};
关于继承方式：填写继承之后变为子类的什么成员
_____________________________________________________________________
|			 |父类public成员 |父类protected成员	 |父类private成员	|
|------------|---------------|-------------------|------------------|
|public继承	 |	1public		 |	2protected		 |		3不可访问	|
|------------|---------------|-------------------|------------------|
|protected继承|	4protected	 |	5protected		 |		6不可访问	|
|------------|---------------|-------------------|------------------|
|private继承 |	7private	 |	8private		 |		9不可访问	|
|____________|_______________|___________________|__________________|

class A
{
	int a;
protected:
	int b;
};
class B : public A
{
private:
	int c;
	void f()
	{
		c;
		//a = 0;
		b = 0;
	}
}


5：----------------------------------------------------------------------
class A
{
	int a;
public:
	A(int aa)
	{
		a = aa;
	}
};

完成B类代码！B类的成员必须含一个有A类对象
class C
{
public:
	C(int a){}
};
class B : C
{
	//const int a;
	//int& b;
	//int* const p;
	//A a;
	A a2;
public:
	B() : a2(5),a(10),p(), C(4)
	{
	}
};
6:----------------------------------------------------------------------
完成A类中有:      写为.h 和.cpp
1)内联函数f1,
2)内联函数f2,（第二种写法）
3)普通成员函数f3,
4)静态成员函数f4（非内联）,
5)静态成员变量f5
-----------a.h---------------
#ifndef _A_H_
#define _A_H_

class A
{public:
	void f1()
	{
	}

	inline void f2();

	void f3();

	static void f4();

	static int f5;
};

void A::f2()
{
}


#endif




-----------a.cpp-------------
#include "a.h"

void A::f3()
{
}

void A::f4()
{
}

int A::f5 = 1000;



---1.cpp
#include "a.h"
---2.cpp
#include "a.h"
---3.cpp
#include "a.h"


7:----------------------------------------------------------------------
写出每条语句后面会输出什么？
class ZB
{
	int x;
	int y;
public:
	ZB(int a):x(a),y(a)
	{
		std::cout<<"构造1";
	}
	ZB(int xx,int yy):x(xx),y(yy)
	{
		std::cout<<"构造2";
	}
	ZB(const ZB& that)
	{
		x = that.x;
		y = that.y;
		std::cout<<"拷贝构造";
	}

	ZB& operator = (const ZB& that)
	{
		x = that.x;
		y = that.y;
		std::cout<<"同类赋值";
	}
};

void f1(A& a)
{
}
void f2(A a)
{
}
void main()
{
	ZB a1(1,2);//？  参数是2个-》构造2
	ZB a2(3);//?	参数是1个-》 类型是int-》 构造1
	ZB a3(a1);//?	参数是1个-》类型是ZB-》  拷贝构造
	ZB a4 = a2;//? 参数是1个-》类型是ZB-》  拷贝构造
	ZB a5 = 3;//?	参数是1个-》类型是int-》 构造1
	ZB a6 = (1,2);//?参数是1个-》后面是逗号表达式，类型是int-》 构造1
	f1(a1);//?	形参是引用，不会开内存-》没有输出
	f2(a2);//?	拷贝构造
	a1 = a4;//	同类赋值 
}


8：----------------------------------------------------------------------
#define DATA Moster*
class vector
{
	DATA* p;
	int len;
public:
	vector()
	{
		len = 0;
		p = new DATA[1];
	}
	~vector()
	{
		for (int i = 0;i < len; ++i)
			delete p[i];
		delete [] p;
	}
	void push_back(DATA m)
	{
		DATA* np = new DATA[len+2];
		for (int i = 0;i < len; ++i)
			np[i] = p[i];
		delete [] p;
		p = np;
		p[len++] = m;
	}
	int size()
	{
		return len;
	}
};

void Add(vector& a, Moster* m)
{
	a.push_bak(m);
}

void main()
{
	//一个表
	vector list;

	//该Add函数，可以把Moster堆对象添加到list中放在最后
	Add(list, new Moster);
	Add(list, new Moster);
	Add(list, new Moster);

	//list的成员函数push_back也可以把Moster堆对象添加进去放在最后
	Moster* p = new Moster;
	list.push_back(p);

	list.push_back(new Moster);
	list.push_back(new Moster);

	//list的size函数可以输出里面存储了多少个怪
	std::cout<< list.size() ;//输出6
}


完成vector类的push_back函数，
完成vector类的size函数，
完成Add函数，

9:----------------------------------------------------------------------

class vector
{
	int p[5];
	int len;
public:
	vector()
	{
		len = 0;
	}
	void push_back(int n)
	{
		p[len++] = n;
	}
	int size()
	{
		return len;
	}
	void print()
	{
		for (int i = 0;i < 5; ++i)
			std::cout<< p[i];
	}

	int& operator [] (index)
	{
		return p[index];
	}
	//完成其他需要的函数！！！！！
};

void Bubble(vector& a) //完成该空格
{
	for (int i = a.size()-1; i > 0; --i)
	{
		for (int j = 0;i < j; ++j)
		{
			if (a[j] > a[j+1])
			{
				int temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
			}
		}
	}
}

void main()
{
	vector a;
	a.push_back(1);
	a.push_back(5);
	a.push_back(8);
	a.push_back(0);
	a.push_back(3);

	Bubble(a);//（冒泡排序）!!	
	a.print();//输出结果是 0 1 3 5 8
}


10:--------------------------------------------------------------
class Hero
{
	friend class Moster;
	int hp;
public:
	Hero(int h) : hp(h) {	}
};

class Moster
{
	int att;
public:
	Moster(int at) : att(at) {}

	void Attack(Hero* hero)
	{
		hero->hp -= att;
	}
};

void main()
{
	Moster* ms[5] = {
		new Moster(5),
		new Moster(20),
		new Moster(15),
		new Moster(7),
		new Moster(10),
	};
	Hero hero(1000);

	while (1)
	{
		//请完成代码，要求如下：
		//1)每次循环有10%的几率英雄被怪物攻击
		//2)如果英雄被攻击，则随机选择一只怪物攻击英雄

		if (rand() % 10 < 1)
		{
			ms[rand()%5]->Attack(&hero);
		}
	}

	for (int i = 0;i < 5; ++i)
		delete ms[i];
}

//另外这份代码有一个错误，请找出来并修改,两种方法！！