我知道 C++ 中的 overriding 是什么。但是，是否存在覆盖？如果有，是什么意思？
谢谢。
【问题讨论】：
标签： c++ overriding overwrite
在 C++ 术语中，您有 覆盖（与类层次结构中的虚拟方法相关）和 重载（与具有相同名称但采用不同参数的函数相关） .您还可以隐藏名称（通过在嵌套的声明性区域或范围中显式声明相同的名称）。
C++ 标准不使用术语“覆盖”，除了其规范的英文形式（即用新值替换一个值，如赋值 x = 10 中覆盖之前的 x 值） .
【讨论】：
您可以覆盖变量，例如int a = 0; a = 42; 和文件（打开现有文件进行写入 - 如果您有权限，它将覆盖现有文件内容）如果这就是您的意思。这与覆盖几乎没有关系。您是否考虑过重载？
【讨论】：
我熟悉的通常区别是覆盖和重载。 虚函数被覆盖。当存在同名但不同签名的版本时（这存在于许多语言中），函数会被重载。在 C++ 中，您还可以重载运算符。
AFAIK，覆盖是一个不相关的概念（覆盖变量、文件、缓冲区等），并不特定于 C++ 甚至 OOP 语言。
【讨论】：
std::sqrt() 已超载。
Override 是 OOP 中的“正常事物”：派生类为某些东西提供不同的（即更专业的）实现，覆盖基类，例如apple::foo() 覆盖 fruit::foo() 如果 apple 是从水果派生的类。 （不要误认为是 overload 使用不同的参数签名，这会导致完全不同的功能）。
覆盖我知道要完全替换为另一个定义。不是在特定级别上，而是一般用于程序的其余部分。这有时会被使用 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++ 中有任何这样的事情，因为同时重新定义函数总是会在编译时导致错误。最多，我可以想象弯曲函数指针，或者（重新）定义回调钩子。
【讨论】：
C++ 函数覆盖。如果派生类定义了与其基类中定义的相同的函数，则在 C++ 中称为函数覆盖。它用于实现运行时多态性。它使您能够提供其基类已经提供的功能的具体实现。
【讨论】：
Override 是指在基类中创建一个带有 virtual 关键字的方法，并且基类允许子类 为它自己制作一个相同方法的主体。
Overwrite 的意思是 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
*/
【讨论】：