【C++】面向对象编程：继承与多态的魅力

//class 派生类名 :继承方式 基类名
class Person
{
  //....
};

class Studen:public Person//定义继承
{
  //...
};
*************************************************************
#include<iostream>
#include<string>
using namespace std;

class Person
{
public:


protected:
	string _name;
	string _address;
	int _age=18;
	string _tel;
};

class teacher:public Person
{
public:
	void identity()
	{
		cout << "teacher:" << "void identity()" << endl;
	}

protected:
	string _title;
};

class student:public Person
{
public:
	void identity()
	{
		cout << "student:" << "void identity()" << endl;
	}
protected:
	int _stuid;
};

int main()
{
	student s;
	teacher t;

	s.identity();
	t.identity();

	return 0;
}

namespace liu
{
	//template<class T>
	//class vector
	//{};
	// stack和vector的关系，既符合is - a，也符合has - a
	template<class T>
	class stack : public std::vector<T>
	{
	public:
		void push(const T& x)
		{
			// 基类是类模板时，需要指定⼀下类域，
			// 否则编译报错: error C3861 : “push_back”:找不到标识符
			// 因为stack<int>实例化时，也实例化vector<int>了

			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
			//push_back(x);
			vector<T>::push_back(x);
			//push_back(x);
		}
		void pop()
		{
			vector<T>::pop_back();
		}
		const T& top()
		{
			return vector<T>::back();
		}
		bool empty()
		{
			return vector<T>::empty();
		}
	};
}

template<class Container>
void Print(const Container& c)
{
  //这里需要注意，因为这里是模板，所以需要在Container前面加typename。
  //因为这是一个模板，Container是模板参数，编译器不知道Container是什么类型，它可能是一个内嵌类型，也可能是一个静态成员变量，因此，我们需要在前面加上一个typename告诉编译器Container是一个类型，
  typename Container::const_iterator it1=c.begin();
  while(it1!=c.end())
  {
    cout<<*it1<<endl;
     ++it1;
  }
  cout<<endl;
}

int main()
{
  
return 0;
}

class Person
{
protected:
	string _name;
	string _sex;
	int _age;
};

class student:public Person
{
public:
	int _stuid;
};

int main()
{
	student sobj;

	//赋值兼容转换，也叫切片或者切割。是一种特殊处理
	//派生类对象赋值给基类的指针或者引用
	Person* pp = &sobj;
	Person& rp = sobj;
  //当然，派生类对象也能给基类对象。
  //将派生类对象中基类的部分切割出来赋值给基类对象，只不过在语义上，将派生类对象赋值给基类的指针或者引用被叫做切割和切片

	return 0;
}

class Person
{
protected:
	string _name="老王";
	int _num = 111;
};

class studen :public Person
{
public:
	void Print()
	{
		cout <<"姓名"<< _name << endl;
		cout <<"身份证号"<< Person::_num << endl;
		cout <<"学号"<<_num << endl;
	}
protected:
	int _num = 999;
};

int main()
{
	studen s;
	s.Print();
	return 0;
}

class A
{
private:
	A()
	{}
};

class B :public A
{
public:
	B()
	{
		cout << "B()" << endl;
	}
};

class A final
{
public:
	A()
	{}
};

class B :public A
{
public:
	B()
	{
		cout << "B()" << endl;
	}
};

class Student;

class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name;//姓名
};

class Student :public Person
{
protected:
	string _stuNum;//学号
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	//cout << s._stu<<endl;
  cout << endl;
}

int main()
{
	Person p;
	Student s;

	Display(p,s);

	return 0;
}

class Person
{
public:
	string _name;
};

class student:virtual public Person
{
protected:
	int _num;//学号
};

class teacher :virtual public Person
{
protected:
	int _id;//职工编号
};

class Assistant : public student, public teacher
{
protected:
	string _majorCourse; // 主修课程
};
int main()
{
	//_name访问不明确
	Assistant a;
	//a._name = "peter";

	a.student::_name = "xxx";
	a.teacher::_name = "yyy";

	return 0;
}

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "全价票" << endl;
	}
};

class Student:public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "半价票" << endl;
	}
};

//与ptr无关，与ptr指向的对象有关
void func(Person& ptr)
{
	ptr.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	func(ps);
	func(st);

	return 0;
}

class Animal
{
public:
	virtual  void call()const {};
};

class dog:public Animal
{
public:
	  void call()const
	{
		cout << "旺旺" << endl;
	}
};
class cat :public Animal
{
public:
	  void call()const
	{
		cout << "喵喵" << endl;
	}
};

void letsHear(const Animal* ptr)
{
	ptr->call();
}


int main()
{
	dog d;
	cat c;
	letsHear(&d);
	letsHear(&c);

	return 0;
}

以下程序输出结果是什么（）
A:A->0    B:B->1   C:A->1   D:B->0   E:编译出错    F:以上都不正确

 class A
 {
 public:
   virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;}
   virtual void test(){ func();}
 };

 class B : public A
 {
 public:
   void func(int val = 0){ std::cout<<"B->"<< val <<std::endl; }
 };

 int main(int argc ,char* argv[])
 {
    B*p = new B;
    p->test();
   
   return 0;
 }
/*
答案：B
通过test函数的this指针调用func函数，此时this是基类的类型，满足多态的条件①，观察基类与派生类的func函数，是虚函数的重写覆盖，满足多态条件②，所以构成多态，但是！！！在多态条件下，派生类的虚函数重写可以理解为是用virtual void func(int val = 1)来进行重写的，也就是拿基类的虚函数的除函数体外的部分来进行重写，所以val的值是1
*/

class A {};
class B :public A{};

class Person {
public:
	virtual A* BuyTicket()
	{
		cout << "买票全价" << endl;
			return nullptr;
	}
};
class Student : public Person {
public:
	virtual B* BuyTicket()
	{
		cout << "买票打折" << endl;
			return nullptr;
	}
};
void Func(Person* ptr)
{
	ptr->BuyTicket();
}

class A
{
public:
	virtual ~A()
	{
		cout << "~A()" << endl;
	}
};
class B : public A {
public:
	~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};
int main()
{
	A* p1 = new A;
	A* p2 = new B;

	delete p1;
	delete p2;

	return 0;
}

class Car
{
public:
	 void Drive() {};//没有重写，报错
};

class Benz :public Car
{
public:
	virtual void Drive()override 
	{ cout << "Benz" << endl; };

};

void Func(Car*ptr)
{
	ptr->Drive();
}
------------------------------
  class Car
{
public:
	virtual void Drive()final {};
};

class Benz :public Car
{
public:
	virtual void Drive()//报错，因为Drive被final修饰
	{ cout << "Benz" << endl; };

};

void Func(Car*ptr)
{
	ptr->Drive();
}

class Car
{
public:
	virtual void Drive() = 0;
};

class Benz:public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz" << endl;
	}
};

void Func(Car* ptr)
{
	ptr->Drive();
}

int main()
{
	//Car c;//纯虚函数不能用来实例化对象
	Benz c;//若派生类也没定义纯虚函数的实现，那么派生类也无法用来实例化对象
	Func(&c);
	return 0;
}
-------------------------------
  /*
  
  虽然抽象类不能实例化对象，但能定义指针
 */
class Car
{
public:
	virtual void Drive() = 0;
};

class Benz:public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz" << endl;
	}
};

class BMW :public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW操控" << endl;
	}
};

int main()
{
	Car* pBenz = new Benz;
	Car* pBMW = new BMW;

	pBMW->Drive();
	
	return 0;
}

下⾯编译为32位程序的运⾏结果是什么（）
A.编译报错  B.运⾏报错 C.8  D.12

class Base
 {
 public:
 virtual void Func1()
 {
 cout << "Func1()" << endl;
 }
 protected:
   int _b = 1;
   char _ch = 'x';
 };
 int main()
 {
   Base b;
   cout << sizeof(b) << endl;
   
   return 0;
 }
/*
  答案是D
  _b四字节
  _ch1字节
  还要个虚函数表指针四字节
  
  当内存对齐完后，再加上虚函数表指针，一个12字节
*/