C++之继承

概念：
继承：在C++语言中，一个派生类可以从一个基类派生，也可以从多个基类派生。从一个基类派生的继承称为单继承；从多个基类派生的继        承称为多继承。

三种继承权限方式:  public    protected      private  
  1.Public和Protected前两种方式保持基类的所有成员的属性不变，且

 2.派生类可以访问基类的public和protected成员，但仍然不能访问基类的private成员;

 3.private继承将使得基类的所有成员在派生类中表现为private属性。

派生类的定义格式
单继承：

class<派生类名>:<继承方式><基类名>
{
     <派生类新定义成员>
};

多继承：

class<派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
 
{
     <派生类新定义成员>
};

注意：如果省略了继承方式，对class类将默认采用私有继承Private，struct默认采用公有继承Public

继承方式：公有继承(public)、私有继承(private)、保护继承(protected)
1. 公有继承(public)
公有继承的特点是基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态，而基类的私有成员仍然是私有的，不能被这个派生类的子类所访问。

2. 私有继承(private)
私有继承的特点是基类的公有成员和保护成员都作为派生类的私有成员，并且不能被这个派生类的子类所访问。

3. 保护继承(protected)
保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的。

上高清无码大图：

总结：
1.父类的私有成员子类是不可见的
2.public继承是一个接口继承，保持is-a原则
3.protetced/private继承是一个实现继承，父类的某些成员不能被继承，保持has-a原则
4.不管是哪种继承方式，在派生类内部都可以访问基类的公有成员和保护成员，但是基类的私有成员存在但是在子类中不可见

三种继承方式的区别： 稍稍需要点想象力,但是后面结合代码就会清晰很多呦。。。

Public：

1. 基类对象对基类成员：
 公有成员可见，其他不可见。这里保护成员同于私有成员。
2. 派生类对基类成员：
 公有成员和保护成员可见，而私有成员不可见。这里保护成员同于公有成员。
3. 派生类对象对基类成员：
 公有成员可见，其他成员不可见。

    PS：派生类的对象可以访问基类中的公有成员；派生类的成员函数可以访问基类中的公有成员和保护成员。

Private：

1. 基类成员对其对象：
 公有成员可见，其他成员不可见。
2. 基类成员对派生类：
 公有成员和保护成员是可见的，而私有成员是不可见的。
3. 基类成员对派生类对象的可见性：
 所有成员均不可见，因为都已变成private
   PS：私有继承时，基类的成员只能由派生类中的成员函数访问，而且无法再往下继承。

Protected：
   与Private的情况相同。两者的区别仅在于对派生类的成员而言，对基类成员有不同的可见性。

上代码块:

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Num
{
public:
 Num(int x = 1, int y = 2, int z = 3)
  : a(x)
  , b(y)
  , c(z)
 {
  cout << "初始化：";
  cout << "a=" << a ;
  cout << "   b=" << b ;
  cout << "   c=" << c << endl << endl;
 }
 int a=0;
protected:
 int b=0;
private:
 int c=0;
};
//基类成员对派生类：公有成员和保护成员是可见的，而私有成员是不可见的。
class Number:public Num//公有继承
{
public:
 void display()
 {
  cout << "公有继承：";
  cout << "a=" << a ;
  cout << "   b=" << b << endl << endl;
  //cout << "c=" << c << endl;//报错
  a = num; //父类的公有成员在派生类中为公有成员
  b = num; //父类的保护成员在派生类中为保护成员
  //c = num;//public继承，父类私有成员为不可见
 }
private:
 int num = 0;
};
class Number1 :private Num//私有继承
{
public:
 void display1()
 {
  cout << "私有继承：";
  cout << "a=" << a ;
  cout << "   b=" << b << endl << endl;
  //cout << "c=" << c << endl;//报错
  a = num1;//父类的公有成员在派生类中为私有成员
  b = num1;//父类的保护成员在派生类中为私有成员
  //c = num1;//private继承，父类私有成员为不可见
 }
private:
 int num1 = 0;
};
class Number2 :protected Num//保护继承
{
public:
 void display2()
 {
  cout << "保护继承：";
  cout << "a=" << a ;
  cout << "   b=" << b << endl << endl;
  //cout << "c=" << c << endl;//报错
  a = num2;//父类的公有成员在派生类中为保护成员
  b = num2;//父类的保护成员在派生类中为保护成员
  //c = num1;//protect继承，父类私有成员为不可见
 }
private:
 int num2 = 0;
};
int main()
{
 Num N1; //基类成员对其对象：公有成员可见，其他成员不可见
 N1.a = 3;
 //N1.b = 4;//报错
 //N1.c = 5;//报错
 Number Nub;//公有继承--------基类成员对派生类对象：公有成员可见，其他成员不可见
 Nub.a = 6;
 //Nub.b = 7;//报错
 //Nub.c = 8;//报错
 Nub.display();
 Number1 Nub1;//私有继承
 //Nub1.a = 9;//此时的a被私有继承，其可见性已为private
 Nub1.display1();
 Number2 Nub2;//保护继承
 //Nub2.a = 10;//此时的a被保护继承，其可见性已为protected
 Nub2.display2();
 system("pause");
 return 0;
}

运行结果：

根据运行结果相信大家会有些许的疑惑，但是通过 自己单步调试，相信大家就会hia.hia.hia了。

附：水平访问&&垂直访问 了解一下
      派生类的对象对基类访问为水平访问
      派生类的派生类对基类的访问为垂直访问。

规则：
Public:      水平访问和垂直访问对基类中的公有成员不受限制；
Protected:   垂直访问对基类中的公有成员不受限制，水平访问受限。
Private:     水平访问和垂直访问对基类中的公有成员也不能访问；

PS：对于基类中的私有成员，只能被基类中的成员函数和友元函数所访问，不能被其他的函数访问。

友元 也了解一下...

分类：友元类  友元函数

概念&&定义：
友元类：友元类的所有成员函数都是另一个类的友元函数，都可以访问原始类中的隐藏信息（包括私有成员和保护成员）      
  格式： friend class 类名;
  其中：friend和class是关键字，类名必须是程序中的一个已定义过的类。
友元函数：友元函数是可以直接访问类的私有成员的非成员函数。它是 定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend
   格式：friend 类型 函数名(形式参数);

总结：

1.友元类和友元函数的声明可以放在类的公有，保护或私有部分，都说明是该类的一个友元类/友元函数。
2.一个函数可以是多个类的友元函数，只需要在各个类中分别声明。

上代码块：
友元类：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;
class base
{
public:base(int x = 1, int y = 2, int z = 3)
    : pub(x)
    , pro(y)
    , pri(z)
{}
    int pub;
protected:
 int pro;
private:
 friend class Derive;
 //friend void display();
 int pri;
};
class Derive
{
public:
 Derive(int x = 4, int y = 5, int z = 6)
  : _pub(x)
  , _pro(y)
  , _pri(z)
 {
  cout << "友元类：" << endl;
  cout << " pub=" << b.pub;
  cout << "      pro=" << b.pro;
  cout << "      pri=" << b.pri << endl;
  cout << "_pub=" << _pub;
  cout << "     _pro=" << _pro;
  cout << "     _pri=" << _pri << endl;
 }
 int _pub;
protected:
 int _pro;
private:
 int _pri;
 base b;//切记一定要记得传参哦。。
};
int main()
{
 base b;
 Derive d;
 system("pause");
 return 0;
}

运行结果：

友元函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;
class Derive;//对子类的不完全声明，让编译器知道有这么个东西    C++ Primer Plus里面称为forward declaration 前置声明
class base
{
public:base(int x = 1, int y = 2, int z = 3)
	   : pub(x)
	   , pro(y)
	   , pri(z)
       {}
	friend void display(const base& b, const Derive& d);
	int pub;
protected:
	int pro;
private:
	//friend class Derive;
	int pri;
};

class Derive
{
public:
	Derive(int x = 4, int y = 5, int z = 6)
		: _pub(x)
		, _pro(y)
		, _pri(z)
	{}
	int _pub;
protected:
	int _pro;
private:
	friend void display(const base& b,const Derive& d);
	int _pri;
};
void display(const base& b, const Derive& d)
{
	cout << "友元函数：" << endl;
	cout << " pub=" << b.pub;
	cout << "      pro=" << b.pro;
	cout << "      pri=" << b.pri << endl;
	cout << "_pub=" << d._pub;
	cout << "     _pro=" << d._pro;
	cout << "     _pri=" << d._pri << endl;
}

int main()
{
	base b;
	Derive d;
	display(b,d);
	system("pause");
	return 0;
}

运行结果：

总结：

1.尽管类定义中有友元函数原型，友元函数仍然不是成员函数
2.由于友元函数不是任何类的成员函数，所以不能用句柄(对象)加点操作符来调用
3.public, private, protected成员访问符与友员关系的声明无关，因此友元关系声明可在类定义的任何位置。
4.友元与继承友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

继承的作用域
1. 在继承体系中 基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，则构成隐藏(重定义)，子类成员将屏蔽父类对成员的直接访问。
  （在子类成员函数中，可以使用基类::基类成员访问）
3. 注意在实际中在继承体系里面最好不要定义同名的成员。
PS：函数名相同就能构成隐藏(不要求参数和返回值)

说到这里，讲一下“ 隐藏”..

概念：
1.派生类的函数与基类的函数 同名，但参数不同，此时，无论有无virtual关键字，基类的函数将被隐藏。
2.派生类的函数与基类的函数 同名，并且参数也相同，但是基类函数没有virtual关键字，此时，基类的函数被隐藏。

关于重载，隐藏，重写的不同之处日后听我一一道来...

PS： 构成隐藏(重定义)，子类成员将屏蔽父类对成员的直接访问。

上代码块：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;
class base
{
public:base()
  {
     cout << "base()" << endl;
  }
    ~base()
    {
     cout << "~base()" << endl;
    }
    void show()
    {
     cout << "base::show()" << endl;
    }
};
class Derive :public base
{
public:
 Derive()
 {
  cout << "Derive()" << endl;
 }
 ~Derive()
 {
  cout << "~Derive()" << endl;
 }
 void show()
 {
  cout << "Derive::show()" << endl;
 }
};
int main()
{
 Derive d;
 base*pb = &d;
 Derive*pd = &d;
 d.show();//show函数构成隐藏，默认调用子类成员函数
 pb->show();//父类指针指向子类对象，形成切片，所以pb只能指向子类里面的base部分，所以输出base::show()
 pd->show();//子类指针指向子类对象，pd指向整个子类，默认调用子类成员函数
 system("pause");
 return 0;
}

运行结果：

上面提到 切片：（那我们再啰嗦两句。。）

1.子类对象可以赋值给父类对象（切割/切片）//可以这样联想.. 一个孩子多年以后终将会变成父亲
2.父类对象不能赋值给子类对象      //而一个父亲却再也不能变成孩子
3.父类的指针/引用可以指向子类对象  //爸爸可以用手指指着你
4.子类的指针/引用不能指向父类

上代码块：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;
class base
{
public:base(int a=3)
	   :b(a)
{
		   cout << "base()" << endl;
}
	   ~base()
	   {
		   cout << "~base()" << endl;
	   }
	   void show()
	   {
		   cout << "base::show()" << endl;
	   }
	int b;
};

class Derive :public base
{
public:
	Derive() 
		: d1(7)
		, base(4)//父类的构造函数带缺省参数，子类构造函数在初始化列表中必须显式给出
	{
		cout << "b=" << b << endl;
		cout << "d=" << d1 << endl;
		cout << "Derive()" << endl;
	}
	~Derive()
	{

		cout << "~Derive()" << endl;
	}
	void show()
	{
		cout << "Derive::show()" << endl;
	}
	int d1;
};

int main()
{
	base b(6);
	Derive d;
	b = d;//子类对象复制给父类，构成切片也叫切割
	//d = b;//父类对象不能赋值给子类对象

	base* pb= &d;// 父类的指针/引用可以指向子类
	base& rb = d;

	Derive* pd1 = (Derive*)&b;//子类的指针/引用不能指向父类对象（可以通过强制类型转换完成）
	Derive& rd1 = (Derive&)b;
	
	pd1->show();//这个指针可以输出Derive::show(),因为show()是函数，存放于代码区
	cout << pd1->d1 << endl;//子类指向父类的指针，虽然可以调子类的成员但是仅仅是只知道有这么块地方，并不知道里面是啥，所以打印的是内存地址
	system("pause");
	return 0;
}

运行结果：

以上大概就是我学习继承时候的一些认识，要有理解的不对，还望批评指正呀。。