C++多态之笔记

1.继承类型（参考博客：http://blog.sina.com.cn/s/blog_648d306d0100rzs6.html）

私有继承，公有继承，和保护继承三种，主要是子类在类内，类外使用基类的成员的权限不同。

例如，基类A，B继承A，C继承B

B继承A的方式有两方面的影响：

①B在类内、类外使用A成员的权限

②C在类内、类外使用A成员的权限

测试代码如下：

class A
{
  public:
    int m_public;
  protected:
    int m_protected;
  private:
    int m_private;
};

class B :public A
{
   void SetPublic(int nPublic)
   {
       m_public = nPublic;
   }
   void SetProtected(int nProtected)
   {
       m_protected = nProtected;
   }
   void SetPrivate(int nPrivate)
   {
       m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};

B b;                  //创建B类的对象c
b.m_public = 100;     //正确
b.m_protected = 100;  //错误，public继承中基类的protected在派生类中是protected
b.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了


class C :protected A
{
   void SetPublic(int nPublic)
   {
       m_public = nPublic;
   }
   void SetProtected(int nProtected)
   {
       m_protected = nProtected;
   }
   void SetPrivate(int nPrivate)
   {
       m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};

C c;                  //创建C类的对象c
c.m_public = 100;     //错误，protected继承C类里变成了protected成员
c.m_protected = 100;  //错误，protected继承C类里还是protected成员
c.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了


class D :private A
{
   void SetPublic(int nPublic)
   {
       m_public = nPublic;
   }
   void SetProtected(int nProtected)
   {
       m_protected = nProtected;
   }
   void SetPrivate(int nPrivate)
   {
       m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};

D d;                  //创建D类的对象d
d.m_public = 100;     //错误，private继承D类里变成了private成员
d.m_protected = 100;  //错误，private继承D类里变成了private成员
d.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了

分析：①A的公有成员和保护成员在B中权限不变，即在B类内均可访问，在类外不可访问A的保护成员

           ②A的公有成员和保护成员在C中变为保护成员属性，即在C类内均可访问，在类外不可访问

           ③A的公有成员和保护成员在D中均变为私有成员属性，访问同2；

看起来私有继承和保护继承的效果是一样的，其实他们的效果体现在下一层继承，测试代码：

class E :public B
{
   void SetPublic(int nPublic)
   {
      m_public = nPublic;        //正确  因为这是B类的公有成员
   }
   void SetProtected(int nProtected)
   {
      m_protected = nProtected;  //正确  因为这是B类的保护成员，现成变成E类的protected成员
   }
   void SetPrivate(int nPrivate)
   {
      m_private = nPrivate;      //错误，因为基类的private成员不能用
   }
};
E e;                  //创建E类的对象e
e.m_public = 100;     //正确
e.m_protected = 100;  //错误，protected继承E类里变成了protected成员
e.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了

class F  :public C
{   
   void SetPublic(int nPublic)
   {
      m_public = nPublic;         //正确 因为这是C类的protected成员
   }
   void SetProtected(int nProtected)
   {
      m_protected = nProtected;   //正确因为这是C类的protected成员，现成变成F类的protected成员
   }
   void SetPrivate(int nPrivate)
   {
      m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};
F f;                  //创建F类的对象f
f.m_public = 100;     //错误，在C类里就已变成protected成员
f.m_protected = 100;  //错误，protected继承E类里变成了protected成员
f.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了

class G  :public D
{
   void SetPublic(int nPublic)
   {
      m_public = nPublic;         //错误 因为这是D类的private成员
   }
   void SetProtected(int nProtected)
   {
      m_protected = nProtected;   //错误因为这是D类的private成员
   }
   void SetPrivate(int nPrivate)
   {
      m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};

分析：①继承方式对类内的影响体现了，私有继承时，在G中类内类外均不可访问

2.多态性调用

多态性调用分为两种：静态绑定（即函数重载）和动态绑定（虚函数），也有人称为编译时多态和运行时多态。本来重载和覆盖很好区别，但是C++的隐藏规则，很容易使人迷惑。

①多态性（晚绑定）的使用基础是赋值兼容，而赋值兼容成立的条件是公有继承，因此，只有公有继承方式才能实现运行时多态

②虚函数语法：

 基类：virtual 返回值类型 函数名（参数列表）；

派生类：（virtual）可以省略，函数名和参数列表同基类完全一致，即通过覆盖实现多态；若参数列表不一致，则为重载，就会产生隐藏，不能实现多态的效果。

③虚函数的实现原理

在包含虚函数的类中，编译器都会隐形的定义一个指针，指向虚表，虚表中存放的是虚函数的偏移量而非地址

表中虚函数的位置与基类中虚函数的声明顺序一致

虚表指针大小为4字节

若子类对基类中的虚函数没有覆盖，则在虚表中存放的就是基类虚函数 的地址

④多态性调用的实现（与指针类型无关，而与指向的对象有关）

例程：

#include<iostream>
using namespace std;

class A
{
public:
	void foo()
	{
		printf("1\n");
	}
	virtual void fun()
	{
		printf("2\n");
	}
};
class B : public A
{
public:
	void foo()
	{
		printf("3\n");
	}
	void fun()
	{
		printf("4\n");
	}
};
int main(void)
{
	A a;
	B b;
	A *p = &a;
	p->foo();
	p->fun();
	p = &b;
	p->foo();
	p->fun();
	return 0;
}

 第一个p->foo()和p->fuu()都很好理解，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。

 第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象，正式体现多态的用法；

还有一种调用，是定义子类指针，指向基类，是不安全的，因此需要进行强制类型转换

 B *ptr = (B *)&a;  ptr->foo();  ptr->fun();
调用结果为3 2

从上面明显可以看出，多态性调用可指针类型无关，只和指向的对象有关；而隐藏规则恰恰相反，和指向的对象无关，只和指针的类型相关；接下来就分析隐藏规则。

3.隐藏规则

例程

//小结：1、有virtual才可能发生多态现象
// 2、不发生多态（无virtual）调用就按原类型调用
#include<iostream>
using namespace std;

class Base
{
public:
	virtual void f(float x)
	{
		cout<<"Base::f(float)"<< x <<endl;
	}
	void g(float x)
	{
		cout<<"Base::g(float)"<< x <<endl;
	}
	void h(float x)
	{
		cout<<"Base::h(float)"<< x <<endl;
	}
};
class Derived : public Base
{
public:
	virtual void f(float x)
	{
		cout<<"Derived::f(float)"<< x <<endl;   //多态、覆盖
	}
	void g(int x)
	{
		cout<<"Derived::g(int)"<< x <<endl;     //隐藏
	}
	void h(float x)
	{
		cout<<"Derived::h(float)"<< x <<endl;   //隐藏
	}
};
int main(void)
{
	Derived d;
	Base *pb = &d;
	Derived *pd = &d;
	// Good : behavior depends solely on type of the object
	pb->f(3.14f);   // Derived::f(float) 3.14
	pd->f(3.14f);   // Derived::f(float) 3.14

	// Bad : behavior depends on type of the pointer
	pb->g(3.14f);   // Base::g(float)  3.14
	pd->g(3.14f);   // Derived::g(int) 3 

	// Bad : behavior depends on type of the pointer
	pb->h(3.14f);   // Base::h(float) 3.14
	pd->h(3.14f);   // Derived::h(float) 3.14
	return 0;
}

出现隐藏的情况：

①子类的参数列表和基类的不一致，无论该函数是否有virtual关键字，基类的函数将被子类的隐藏，即调用时和指向的对象无关，和指针类型相关，区别与重载

②子类的参数列表和基类一致，但无virtual关键字，基类的函数将被子类隐藏，区别与覆盖

4.直接定义对象，而不用指针调用成员函数，那就很简单；只是不能体现多态性

5.析构函数可以定义为虚函数，构造函数不能定义为虚函数

析构函数定义为虚函数的作用，参考博客http://www.cnblogs.com/CaiNiaoZJ/archive/2011/08/11/2134673.html，例程

#include "stdafx.h"
#include <iostream>
#include <string>


class Graph
{
protected:
double x;
double y;
public:
        Graph(double x,double y);
voidvirtual showArea();//定义为虚函数或virtual void showArea()
~Graph();
};

Graph::Graph(double x,double y)
{
this->x=x;
this->y=y;
}

void Graph::showArea()
{
    std::cout<<"计算图形面积"<<std::endl;
}

Graph::~Graph()
{
    std::cout<<"调用图形类析构函数"<<std::endl;
}

class Rectangle:public Graph
{
public:
        Rectangle(double x,double y):Graph(x,y){};
virtualvoid showArea();//定义为虚函数
~Rectangle();
};

void Rectangle::showArea()
{
    std::cout<<"矩形面积为："<<x*y<<std::endl;
}

Rectangle::~Rectangle()
{
    std::cout<<"调用矩形类析构函数"<<std::endl;
}

int main()
{
    Graph *graph;
    graph=new Rectangle(10,5);
    graph->showArea();

    delete graph;

return0;
}

调用结果为：

调用图形类析构函数

没有析构Rectangle对象，将基类析构函数定义为虚析构函数，则可解决问题

虽然派生类的析构函数与基类的析构函数名字不同，但是如果将基类的析构函数定义为虚函数，由该基类派生而来的所有派生类的析构函数都自动成为虚函数。

最后，记录一下this指针的理解

在MFC中，CWnd::OnCreate()中调用了this->PreCreateWindow();

一直以为this指针是指向CWnd的，总也不能理解为什么调用的是子类的PreCreateWindow()；其实this指针指向的是实例化对象，CWnd并未实例化，因此指向的是其派生类对象，因此就完全可以理解了