[转]overload-重载 override-覆盖 overwrite-重写或隐藏

news/2024/7/4 1:44:35 标签: class, float, string, c

cle class="tags" href="/tags/CLASS.html" title=class>class="baidu_pl">

cle_content" class="tags" href="/tags/CLASS.html" title=class>class="article_content clearfix">

content_views" class="tags" href="/tags/CLASS.html" title=class>class="htmledit_views">

转自：http://blog.csdn.net/longhaobo11/archive/2005/12/15/553474.aspx
1.C++中三个概念
函数重载:
在C++程序中࿰c;可以将语义、功能相似的几个函数用同一个名字表示࿰c;即函数重载。
重载的实现:
几个同名的重载函数仍然是不同的函数࿰c;它们是如何区分的呢？我们自然想到函数
接口的两个要素：参数与返回值。如果同名函数的参数不同（包括类型、顺序不同）࿰c;那么容易区别出它们是不同的函数。

重载与覆盖

成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。

覆盖是指派生类函数覆盖基类函数࿰c;特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。

隐藏规则:

本来仅仅区别重载与覆盖并不算困难࿰c;但是C++的隐藏规则使问题复杂性增加了许多。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数࿰c;规则如下：
（1）如果派生类的函数与基类的函数同名࿰c;但是参数不同。此时࿰c;不论有无virtual
关键字࿰c;基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名࿰c;并且参数也相同࿰c;但是基类函数没有virtual
关键字。此时࿰c;基类的函数被隐藏（注意别与覆盖混淆）。

另一观点

如果基类有某个函数的多个重载（overload）版本࿰c;而你在子类中重写(overwrite)了其中的一个࿰c;或是子类添加新的函数版本࿰c;则所有基类的重载版本都被遮蔽。所以࿰c;正常情况下࿰c;在子类中应重写基类中的所有重载版本。

具体地讲࿰c;继承类中的重载和重写都包含了重写的涵义࿰c;即只要函数名一样࿰c;基类的函数版本就会被遮蔽࿰c;所以࿰c;在派生类中要保持基类的重载版本࿰c;就应该重写所有基类的重载版本。重载只在当当前类中有效࿰c;继承会失去重载的特性。也就是说࿰c;把基类的重载函数放在继承类里࿰c;就必须重写。

2.C#中三个概念及实现
转自：http://blog.chinaunix.net/u1/39332/showart_1330863.html

overload (重载)关键字：无
1.使用的地方：同一类里。(其实是同一类里同一名称的方法不同版本的一种叫法)
2.要重载的方法和被重载的方法要求：参数列表不同或返回类型和参数列表都不同࿰c;只有返回类型不同不能重载。(所谓的参数列表不同就是参数个数或者参数类型不同或者二者都不同)

overwrite (重写)关键字：new
1.用来是从父类继承的与是由了new关键字的方法的方法名一样的所以方法无效就像父类里不存在这些方法一样。只要去方法名一样别的没要求。

override (覆写)关键字： override
1.override的方法必须父类的(直接父类或间接父类(就是向上n层的父类))虚方法或抽象方法其中抽象方法是必须覆写的。
2.要求3处相同
相同的方法名称称；
相同的参数列表；
相同的返回类型。

using System;
using System.Collections.Generic;
using System.Text;

namespace Override_Overload_Overwrite
{
    class="tags" href="/tags/CLASS.html" title=class>class Parent
    {
        public void F()
        {
            Console.WriteLine("Parent.F()");
        }
        public virtual void G()
        {
            Console.WriteLine("Parent.G()");
        }
        public int Add(int x, int y)
        {
            return x + y;
        }
        //重载(overload)Add函数
        public class="tags" href="/tags/FLOAT.html" title=float>float Add(class="tags" href="/tags/FLOAT.html" title=float>float x, class="tags" href="/tags/FLOAT.html" title=float>float y)
        {
            return x + y;
        }
    }
    class="tags" href="/tags/CLASS.html" title=class>class ChildOne:Parent
    {
        //重写(overwrite)父类函数
        new public void F()
        {
            Console.WriteLine("ChildOne.F()");
        }
        //覆写(override)父类虚函数,主要实现多态
        public override void G()
        {
            Console.WriteLine("ChildOne.G()");
        }
    }
    class="tags" href="/tags/CLASS.html" title=class>class ChildTwo:Parent
    {
        new public void F()
        {
            Console.WriteLine("ChildTwo.F()");
        }
        public override void G()
        {
            Console.WriteLine("ChildTwo.G()");
        }
    }
    class="tags" href="/tags/CLASS.html" title=class>class Program
    {
        static void Main(class="tags" href="/tags/STRING.html" title=string>string[] args)
        {
            Parent childOne = new ChildOne();
            Parent childTwo = new ChildTwo();
            //调用Parent.F()
            childOne.F();
            childTwo.F();
            //实现多态
            childOne.G();
            childTwo.G();
            Parent load = new Parent();
            //重载(overload)
            Console.WriteLine(load.Add(1, 2));
            Console.WriteLine(load.Add(3.4f, 4.5f));
            Console.Read();
        }
    }
}