总结：对于一个基类（父类）的指针指向派生类（子类）的对象，并且基类指针在调用基类和派生类都有的方法的时候，容易产生混淆。

我的解决方法：

1）首先，将“基类名变量名 = 派生类名 new 派生类对象()”这句话视为：将派生类对象强制转换为基类，派生类的东西没有了（C#中还应该用上as保证安全）

2）然后看变量名调用的方法是否有virtual，如果没有virtual，那就只到基类中找对应方法！如果有virtual，那么就只到派生类中去找！

（实际上有virtual的时候，程序是去寻找变量名所指向的地址里面的对象；而没有virtual的时候是不会去寻找地址而是直接用变量名前面的类名对象，下面的引用的两篇文章，帮助理解）

第一部分：C#中的隐藏---只需要看sleep()函数的用法即可

本文来自：http://www.cnblogs.com/zhangkai2237/archive/2012/12/20/2826734.html

C#中的多态性

相信大家都对面向对象的三个特征封装、继承、多态很熟悉，每个人都能说上一两句，但是大多数都仅仅是知道这些是什么，不知道CLR内部是如何实现的，所以本篇文章主要说说多态性中的一些概念已经内部实现的机理。

一、多态的概念

首先解释下什么叫多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。换句话说，实际上就是同一个类型的实例调用“相同”的方法，产生的结果是不同的。这里的“相同”打上双引号是因为这里的相同的方法仅仅是看上去相同的方法，实际上它们调用的方法是不同的。

说到多态，我们不能免俗的提到下面几个概念:重载、重写、虚方法、抽象方法以及隐藏方法。下面就来一一介绍他们的概念。

1、重载(overload):在同一个作用域(一般指一个类)的两个或多个方法函数名相同，参数列表不同的方法叫做重载，它们有三个特点(俗称两必须一可以):

方法名必须相同
参数列表必须不相同
返回值类型可以不相同

如：

        public void Sleep()
        {
            Console.WriteLine("Animal睡觉");
        }
        public int Sleep(int time)
        {
            Console.WriteLine("Animal{0}点睡觉", time);
            return time;
        }

2、重写(override):子类中为满足自己的需要来重复定义某个方法的不同实现，需要用override关键字，被重写的方法必须是虚方法，用的是virtual关键字。它的特点是(三个相同):

相同的方法名
相同的参数列表
相同的返回值。

如：父类中的定义：

        public virtual void EatFood()
        {
            Console.WriteLine("Animal吃东西");
        }

子类中的定义：

        public override void EatFood()
        {
            Console.WriteLine("Cat吃东西");
            //base.EatFood();
        }

tips:经常有童鞋问重载和重写的区别,而且网络上把这两个的区别作为C#做常考的面试题之一。实际上这两个概念完全没有关系，仅仅都带有一个“重”字。他们没有在一起比较的意义，仅仅分辨它们不同的定义就好了。

3、虚方法：即为基类中定义的允许在派生类中重写的方法，使用virtual关键字定义。如：

        public virtual void EatFood()
        {
            Console.WriteLine("Animal吃东西");
        }

注意：虚方法也可以被直接调用。如：

            Animal a = new Animal();
            a.EatFood();

运行结果：

26、C#：C#中的隐藏和C++中的隐藏

4、抽象方法：在基类中定义的并且必须在派生类中重写的方法，使用abstract关键字定义。如：

    public abstract class Biology
    {
        public abstract void Live();
    }
    public class Animal : Biology
    {
        public override void Live()
        {
            Console.WriteLine("Animal重写的抽象方法");
            //throw new NotImplementedException();
        } 
    }

注意：抽象方法只能在抽象类中定义，如果不在抽象类中定义，则会报出如下错误：

26、C#：C#中的隐藏和C++中的隐藏

虚方法和抽象方法的区别是：因为抽象类无法实例化，所以抽象方法没有办法被调用，也就是说抽象方法永远不可能被实现。

5、隐藏方法：在派生类中定义的和基类中的某个方法同名的方法，使用new关键字定义。如在基类Animal中有一方法Sleep():

        public void Sleep()
        {
            Console.WriteLine("Animal Sleep");
        }

则在派生类Cat中定义隐藏方法的代码为：

        new public void Sleep()
        {
            Console.WriteLine("Cat Sleep");
        }

或者为：

        public new void Sleep()
        {
            Console.WriteLine("Cat Sleep");
        }

注意：（1）隐藏方法不但可以隐藏基类中的虚方法，而且也可以隐藏基类中的非虚方法。

（2）隐藏方法中父类的实例调用父类的方法，子类的实例调用子类的方法。

（3）和上一条对比：重写方法中子类的变量调用子类重写的方法，父类的变量要看这个父类引用的是子类的实例还是本身的实例，如果引用的是父类的实例那么调用基类的方法，如果引用的是派生类的实例则调用派生类的方法。

好了，基本概念讲完了，下面来看一个例子，首先我们新建几个类：

    public abstract class Biology
    {
        public abstract void Live();
    }
    public class Animal : Biology
    {
        public override void Live()
        {
            Console.WriteLine("Animal重写的Live");
            //throw new NotImplementedException();
        }
        public void Sleep()
        {
            Console.WriteLine("Animal Sleep");
        }
        public int Sleep(int time)
        {
            Console.WriteLine("Animal在{0}点Sleep", time);
            return time;
        }
        public virtual void EatFood()
        {
            Console.WriteLine("Animal EatFood");
        }
    }
    public class Cat : Animal
    {
        public override void EatFood()
        {
            Console.WriteLine("Cat EatFood");
            //base.EatFood();
        }
        new public void Sleep()
        {
            Console.WriteLine("Cat Sleep");
        }
        //public new void Sleep()
        //{
        //    Console.WriteLine("Cat Sleep");
        //}
    }
    public class Dog : Animal
    {
        public override void EatFood()
        {
            Console.WriteLine("Dog EatFood");
            //base.EatFood();
        }
    }

下面来看看需要执行的代码：

    class Program
    {
        static void Main(string[] args)
        {
            //Animal的实例
            Animal a = new Animal();
            //Animal的实例，引用派生类Cat对象
            Animal ac = new Cat();
            //Animal的实例，引用派生类Dog对象
            Animal ad = new Dog();
            //Cat的实例
            Cat c = new Cat();
            //Dog的实例
            Dog d = new Dog();
            //重载
            a.Sleep();
            a.Sleep(23);
            //重写和虚方法
            a.EatFood();
            ac.EatFood();
            ad.EatFood();
            //抽象方法
            a.Live();
            //隐藏方法
            a.Sleep();
            ac.Sleep();
            c.Sleep();
            Console.ReadKey();
        }
    }

首先，我们定义了几个我们需要使用的类的实例，需要注意的是

(1)Biology类是抽象类，无法实例化；

(2)变量ac是Animal的实例，但是指向一个Cat的对象。因为Cat类型是Animal类型的派生类，所以这种转换没有问题。这也是多态性的重点。

下面我们来一步一步的分析：

(1)

            //重载
            a.Sleep();
            a.Sleep(23);

很明显，Animal的变量a调用的两个Sleep方法是重载的方法，第一句调用的是无参数的Sleep()方法，第二句调用的是有一个int 参数的Sleep方法。注意两个Sleep方法的返回值不一样，这也说明了重写的三个特征中的最后一个特征——返回值可以不相同。

运行的结果如下：

26、C#：C#中的隐藏和C++中的隐藏

(2)

            //重写和虚方法
            a.EatFood();
            ac.EatFood();
            ad.EatFood();

在这一段中，a、ac以及ad都是Animal的实例，但是他们引用的对象不同，a引用的是Animal对象，ac引用的是Cat对象，ad引用的是Dog对象，这个差别会造成执行结果的什么差别呢，请看执行结果：

26、C#：C#中的隐藏和C++中的隐藏

第一句Animal实例，直接调用Animal的虚方法EatFood，没有任何问题。

在第二、三句中，虽然同样是Animal的实例，但是他们分别指向Cat和Dog对象，所以调用的Cat类和Dog类中各自重写的EatFood方法，就像是Cat实例和Dog实例直接调用EatFood方法一样。这个也就是多态性的体现：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

(3)

            //抽象方法
            a.Live();

这个比较简单，就是直接重写父类Biology中的Live方法，执行结果如下:

26、C#：C#中的隐藏和C++中的隐藏

(4)

            //隐藏方法
            a.Sleep();
            ac.Sleep();
            c.Sleep();

在分析隐藏方法时要和虚方法、重写相互比较。变量 a 调用 Animal 类的 Sleep 方法以及变量 c 调用 Cat 类的 Sleep 方法没有异议，但是变量 ac 引用的是一个 Cat 类型的对象，它应该调用 Animal 类型的 Sleep 方法呢，还是 Cat 类型的Sleep 方法呢？答案是调用父类即Animal的Sleep方法。执行结果如下：

26、C#：C#中的隐藏和C++中的隐藏

大多数的文章都是介绍到这里为止，仅仅是让我们知道这些概念以及调用的方法，而没有说明为什么会这样。下面我们就来深入一点，谈谈多态背后的机理。

二、深入理解多态性

要深入理解多态性，就要先从值类型和引用类型说起。我们都知道值类型是保存在线程栈上的，而引用类型是保存在托管堆中的。因为所有的类都是引用类型，所以我们仅仅看引用类型。

现在回到刚才的例子，Main函数时程序的入口，在JIT编译器将Main函数编译为本地CPU指定时，发现该方法引用了Biology、Animal、Cat、Dog这几个类，所以CLR会创建几个实例来表示这几个类型本身，我们把它称之为“类型对象”。该对象包含了类中的静态字段，以及包含类中所有方法的方法表，还包含了托管堆中所有对象都要有的两个额外的成员——类型对象指针(Type Object Point)和同步块索引(sync Block Index)。

可能上面这段对于有些没有看过相关CLR书籍的童鞋没有看懂，所以我们画个图来描述一下：

26、C#：C#中的隐藏和C++中的隐藏

上面的这个图是在执行Main函数之前CLR所做的事情，下面开始执行Main函数（方便起见，简化一下Main函数）：

            //Animal的实例
            Animal a = new Animal();
            //Animal的实例，引用派生类Cat对象
            Animal ac = new Cat();
            //Animal的实例，引用派生类Dog对象
            Animal ad = new Dog();
            a.Sleep();
            a.EatFood();
            ac.EatFood();
            ad.EatFood();

下面实例化三个Animal实例，但是他们实际上指向的分别是Animal对象、Cat对象和Dog对象，如下图：

26、C#：C#中的隐藏和C++中的隐藏

请注意，变量ac和ad虽然都是Animal类型，但是指向的分别是Cat对象和Dog对象，这里是关键。

当执行a.Sleep()时，由于Sleep是非虚实例方法，JIT编译器会找到发出调用的那个变量（a）的类型（Animal）对应的类型对象（Animal类型对象）。然后调用该类型对象中的Sleep方法，如果该类型对象没有Sleep方法，JIT编译器会回溯类的基类（一直到Object）中查找Sleep方法。

当执行ac.EatFood时，由于EatFood是虚实例方法，JIT编译器调用时会在方法中生成一些额外的代码，这些代码会首先检查发出调用的变量（ac），然后跟随变量的引用地址找到发出调用的对象（Cat对象），找到发出调用的对象对应的类型对象（Cat类型对象），最后在该类型对象中查找EatFood方法。同样的，如果在该类型对象中没有查找到EatFood方法，JIT编译器会回溯到该类型对象的基类中查找。

上面描述的就是JIT编译器在遇到调用类型的非虚实例方法以及虚实例方法时的不同执行方式，也这是处理这两类方法的不同方式造成了表面上我们看到的面向对象的三个特征之一——多态性。

好了，本篇博文开始回顾了一些关于多态性的基本概念，然后解释了多态性的内部机理。内部JIT编译器的部分基本是参照《CLR via C#》书中的第四章的内容，有这本书的同学可以回去翻翻看看。写的不好的地方，请大家批评指正。

第二部分：C++中的隐藏

本文来自：http://www.cnblogs.com/renyuan/archive/2013/06/08/3127562.html

c++中的隐藏、重载、覆盖（重写）

1 重载与覆盖

成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual关键字可有可无。

覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual关键字。

令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
上面的程序中：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

#include <iostream.h>

    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; }
};

void 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        (surprise!)

// Bad : behavior depends on type of the pointer

   pb->h(3.14f); // Base::h(float) 3.14      (surprise!)

  pd->h(3.14f); // Derived::h(float) 3.14
}

26、C#：C#中的隐藏和C++中的隐藏

C#中的多态性

c++中的隐藏、重载、覆盖（重写）

相关推荐