C++学习笔记 lesson12 继承

继承权限

#include<iostream>

class Base
{
public:
	//Base()
	//{
	//	std::cout << "Base::Base()" << std::endl;
	//}
	Base(int num) :num_(num)
	{
		std::cout << "Base::Base()" << std::endl;
	}
	 ~Base()
	{
		std::cout << "Base::~Base()" << std::endl;
	}

	virtual int  GetNum()const //虚函数，寻求子类中最符合的方式
	{
		return num_;
	}
	int public_i_;  //外部可以被访问
protected:
	int protected_i_; //内部可以访问，外部无法访问，可继承，子类可访问
private:
	int private_i_; //只有类内部可以访问
	int num_;
};

class A :public Base    //维持不变
{
public:
	A() :Base(0)   //默认的调用基类的默认构造函数，
		//如果没有默认构造，在初始化列表中初始化
	{
		std::cout << "A::A()" << std::endl;
	}

	~A()
	{
		std::cout << "A::~A()" << std::endl;
	}
	int GetNum() const   //重写后返回子类的num_ 覆盖了父类的方法，父类的方法就不存在了
	{
		return num_;
	}
private:
	int num_ ;
};
class B :protected Base  //修改权限，把public改为protect，外部无法访问
{};
class C :private Base   //把public改为private，外部无法访问
{};

int main()
{
	A demo;//先调用父类的构造函数，再调用自己的构造。析构先析构子类，再析构父类
	demo.GetNum();//若子类没重写返回父类的num_

	A a;
	Base *p_base = &a; //父类的指针指向子类
	return 0;
}

虚函数

#include<iostream>

class A
{
public:
	virtual ~A()
	{}
};
class B:public A
{
public:
	B():A()
	{
		demo_ = new int(0);
	}
	~B()
	{
		delete demo_;
	}
private:
	int *demo_;//指针成员
};
int main()
{
	A *p_a = new B; //只能看到A类的方法和成员，析构的时候会导致B中的成员泄露
					//将A类定义成虚析构函数才能对B类成员进行正确的释放
	// 调用顺序 父类构造 -> 父类成员的构造（类中有其他类的对象）  ->子类构造
        // 析构顺序 子类析构 -> 父类成员析构   -> 父类析构
	return 0;
}

MyString 重写 +  虚函数实现

#include <cstring>
#include<iostream>
class String
{
public:
	String(const char *str = "")
	{
		unsigned int len = strlen(str);
		str_ = new char[len + sizeof(char)];
		strcpy(str_, str);
	}
	String(const String &other)
	{
		unsigned int len = strlen(other.str_);
		str_ = new char[len + sizeof(char)];
		strcpy(str_, other.str_);
	}
	~String()
	{
		delete[]str_;
	}
	String &operator+=(const String &other)
	{
		unsigned int len = strlen(str_) + strlen(other.str_);
		char *temp = new char[len + sizeof(char)];
		strcpy(temp, str_);
		strcat(temp, other.str_);
			delete[]str_;
		str_ = temp;
		return *this;
	}
	virtual String operator+(const String &other)
	{
		String demo=*this;
		demo+= other;
		return demo;
	}
	friend std::ostream&operator<<(std::ostream&os, const String&other)
	{
		os << other.str_;
		return os;
	}
protected:
	char *str_;
};
class MyString :public String
{
public:
	MyString(const char *str="PoEdu"):String(str)
	{

	}
	String operator + (const String &other)
	{
		MyString temp=*this;
		temp += other; // 继承了+=
		temp += "----PoEdu";
		return temp;
	}
	
};
int main()
{
	MyString str("I Love");
	String *p_string = &str;
	std::cout << str + ("Mark") << std::endl;
	std::cout << *p_string+("Mark") << std::endl; //调用的是父类里面的+ ,把+做成虚函数后就会调用子类的+
	return 0;
}

虚继承

class  A
{
public:
	int a_;

};

class B :virtual public A
{
public:
	int b_;
};
class C: virtual public A
{
public:
	int c_;
};

class D : public B, public C // 使用虚继承只继承了一个a_
{
	//无虚继承时有a_*2  b_ c_ 
};
int main()
{
	D d;
	//d.a_; 不使用虚继承有二义性
	//d.C::a_;
	d.a_;//虚继承
	return 0;
}

纯虚函数

//有纯虚函数的类就是抽象类，抽象类不能创建对象，是其他类的基类 ,一般用来当接口使用
class Animal
{
public:
	virtual void Cry()=0;//纯虚函数，无须实现
	
};
class Dog :public Animal  //必须实现Cry 才能被实例化
{
public:
	void Cry()
	{}
};

int main()
{
	Animal *animal = new Dog();
	animal->Cry();
	return 0;
}