Question

我知道覆盖在C ++中是什么。但是，覆盖？如果是这样，那是什么意思？

感谢。

Answer 1

在C ++术语中，您有覆盖（与类层次结构中的虚拟方法相关）和重载（与具有相同名称但使用不同参数的函数相关）。您还有隐藏名称（通过在嵌套声明性区域或范围中显式声明相同名称）。

C ++标准不使用术语“覆盖”，除了它的规范英语形式（即，用一个新值替换一个值，如在赋值x = 10中覆盖x的先前值{{1}} 1}}）。

Answer 2

您可以覆盖变量，例如int a = 0; a = 42;和文件（打开现有文件进行写入 - 如果您有权限，它将覆盖现有文件内容），如果这就是您的意思。这与覆盖相关性很小。您是否想过载？

Answer 3

我熟悉的通常区别是覆盖和重载。虚拟功能被覆盖。当版本具有相同名称但签名不同（多种语言中存在）时，函数会重载。在C ++中，您还可以重载运算符。

AFAIK，覆盖是一个不相关的概念（覆盖变量，文件，缓冲区等），并不是特定于C ++甚至是OOP语言。

Answer 4

覆盖在OOP中是“正常的东西”：派生类为某些东西提供了一种不同的（即更专业的）实现，覆盖了基类，例如：如果apple是从水果派生的类，则apple::foo()会覆盖fruit::foo()。（不要误用重载使用不同的参数签名，这会导致完全不同的功能）。

覆盖我知道要完全替换另一个定义。不是在特定的级别，而是一般的程序的其余部分。这有时会被javascript使用，如果一个大框架有一些特殊问题，你不想拆开大文件：

<script type="text/javascript" 
    src="some super big framework, often in one big file">
<script type="text/javascript">
  Ext.ux.window.createWin = function() {
     // completely OVERWRITE the implementation 
       (often to 'hotfix' a particular bug)
  }
</script>

但是：我不知道C ++中有任何这样的东西，因为对函数的同意重新定义总是会在编译时导致错误。最多，我可以想象弯曲函数指针，或者（重新）定义回调挂钩。

Answer 5

C ++函数重写。如果派生类定义的函数与其基类中定义的函数相同，则在C ++中称为函数重写。它用于实现运行时多态。它使您能够提供其基类已经提供的功能的特定实现。

Answer 6

<块引用>

Override 是指在基类中创建一个带有 virtual 关键字的方法，并且基类允许子类为你自己制作一个相同方法的主体。

覆盖是指没有虚拟关键字的覆盖。

重载是指用同一个名字制作多个输入参数不同的方法。

样本：

    #include <stdio.h>
    #include <stdlib.h>
    class par_overwrite
    {public:    par_overwrite() {}; ~par_overwrite() {};
        int at() { return 1; };
    };
    class chld_overwrite :public par_overwrite
    {public:    chld_overwrite() {};    ~chld_overwrite() {};
        int at() { return 2; }//overwrite
    };
    void main_overwrite()
    {
        par_overwrite pt;
        int ptat = pt.at();
        chld_overwrite ct;
        int ctat = ct.at();
        printf("ptat:%d,ctat:%d\n",ptat, ctat);  //output : ptat:1,ctat:2
    }
    class par_override
    {public:    par_override() {};  ~par_override() {};
        virtual int ad() { return 3; };
    };
    class chld_override :public par_override
    {public:    chld_override() {}; ~chld_override() {};
        int ad() { return 4; }//override
    };
    void main_override()
    {
        par_override pd;
        int pdad = pd.ad();
        chld_override cd;
        int cdad = cd.ad();
        printf("pdad:%d,cdad:%d\n", pdad, cdad); //output : pdad:3,cdad:4
    }
    class par_override_pure
    {public:    par_override_pure() {}; ~par_override_pure() {};
        virtual int adp()=0;//Pure Virtual Function
    };
    class chld_override_pure :public par_override_pure
    {public:    chld_override_pure() {};    ~chld_override_pure() {};
        int adp() { return 5; }//override from Pure Virtual Function
    };
    void main_override_pure()
    {
        //par_override_pure pdp;//error : Can not create object from abstract class that have (Pure Virtual Function)
        //int pdpad = pdp.ad();//error
        chld_override_pure cdp;
        int cdpadp = cdp.adp();
        printf("cdpadp:%d\n", cdpadp); //output : cdpadp:5
    }
    class overload
    {public:    overload() {}; ~overload() {};
        void method_overload(int prm1) { printf("ol1\t"); }
        void method_overload(int prm1, int prm2) { printf("ol2\t"); }
        void method_overload(int prm1, int prm2, int prm3) { printf("ol3\t"); }
        void method_overload(double prm1) { printf("ol4\t"); }
        void method_overload(double prm1, double prm2) { printf("ol5\t"); }
        void method_overload(double prm1, double prm2, double prm3) { printf("ol6\t"); }
    };
    void main_overload()
    {
        overload ol;
        ol.method_overload(1);
        ol.method_overload(1, 1);
        ol.method_overload(1, 1, 1);
        ol.method_overload(0.1);
        ol.method_overload(0.1, 0.1);
        ol.method_overload(0.1, 0.1, 0.1); // output : ol1     ol2     ol3     ol4     ol5     ol6
    }
    int main()
    {   main_overwrite();
        main_override();
        main_override_pure();
        main_overload();

        getchar();
        return 0;
    }
    /* output:
    ptat:1,ctat:2
    pdad:3,cdad:4
    cdpadp:5
    ol1     ol2     ol3     ol4     ol5     ol6
    */

C ++覆盖...覆盖？

6 个答案: