求大神解答为什么老说我的“sqrt”: 对重载函数的调用不明确

_Check_return_ _CRT_JIT_INTRINSIC double __cdecl sqrt(_In_ double _X);

首先重载：一个是函数个数不一致，一个是函数类型不一致；

你上面的传入的是一个int 类型，原本内部的是一个double类型。

重载：是类的多态的一种实现。函数重载指一个标识符被用作多个函数名，且能够通过函数的参数个数或参数类型将这些同名的函数区分开来，调用不发生混淆。这样做的主要好处就是，不用为了对不同的参数类型或参数个数，而写多个函数。也就是说，我们可以用同一个函数名定义多个同名方法，在我们调用这个函数的时候，就会根据参数列表的个数和参数类型来区分调用。

1、方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数类型。重载是一个类中多态性的一种表现；

2、Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性；

3、重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

使程序更加简洁，减少编程时间，让自己容易理解。

看下面一个表示string对象的类：

// 一个很简单的string类

class string {

public:

string(const char value);

~string();

// 没有拷贝构造函数和operator=

private:

char data;

};

string::string(const char value)

{

if (value) {

data = new char[strlen(value) + 1];

strcpy(data, value);

}

else {

data = new char[1];

data = '\0';

}

}

inline string::~string() { delete [] data; }

请注意这个类里没有声明赋值 *** 作符和拷贝构造函数。这会带来一些不良后果。

如果这样定义两个对象：

string a("hello");

string b("world");

其结果就会如下所示：

a: data——> "hello\0"

b: data——> "world\0"

对象a的内部是一个指向包含字符串"hello"的内存的指针，对象b的内部是一个指向包含字符串"world"的内存的指针。如果进行下面的赋值：

b = a;

因为没有自定义的operator=可以调用，c++会生成并调用一个缺省的operator= *** 作符（见条款45）。这个缺省的赋值 *** 作符会执行从a的成员到b的成员的逐个成员的赋值 *** 作，对指针(adata和bdata) 来说就是逐位拷贝。赋值的结果如下所示：

a: data --------> "hello\0"

/

b: data --/ "world\0"

这种情况下至少有两个问题。第一，b曾指向的内存永远不会被删除，因而会永远丢失。这是产生内存泄漏的典型例子。第二，现在a和b包含的指针指向同一个字符串，那么只要其中一个离开了它的生存空间，其析构函数就会删除掉另一个指针还指向的那块内存。

string a("hello"); // 定义并构造 a

{ // 开一个新的生存空间

string b("world"); // 定义并构造 b

b = a; // 执行 operator=,

// 丢失b的内存

} // 离开生存空间, 调用

// b的析构函数

string c = a; // cdata 的值不能确定!

// adata 已被删除

例子中最后一个语句调用了拷贝构造函数，因为它也没有在类中定义，c++以与处理赋值 *** 作符一样的方式生成一个拷贝构造函数并执行相同的动作：对对象里的指针进行逐位拷贝。这会导致同样的问题，但不用担心内存泄漏，因为被初始化的对象还不能指向任何的内存。比如上面代码中的情形，当cdata用adata的值来初始化时没有内存泄漏，因为cdata没指向任何地方。不过，假如c被a初始化后，cdata和adata指向同一个地方，那这个地方会被删除两次：一次在c被摧毁时，另一次在a被摧毁时。