我定义了两个函数，这两个函数只是在返回值处不同，其他都一样，但是第二个有错误：
bignum bignum::operator +(int num)
{
    bignum temp(num);
    temp=add(*this,temp);
    //return add(*this,temp);
    return temp;
}

bignum bignum::operator +(double num)
{
    bignum temp(num);
    //temp=add(*this,temp);
    return add(*this,temp);
}
编译输出：
e:\临时程序\bignum\bignum\bignum.cpp(105) : error C2668: “bignum::bignum”: 对重载函数的调用不明确
1>        e:\临时程序\bignum\bignum\bignum.h(15): 可能是“bignum::bignum(double)”
1>        e:\临时程序\bignum\bignum\bignum.h(14): 或       “bignum::bignum(int)”
1>        试图匹配参数列表“(bignum)”时

add定义：bignum add(bignum &,bignum &)
{
    bignum temp;
         /*代码*/
         return temp;
}
构造函数：bignum();
    bignum(int);
    bignum(double);
    bignum(bignum &);


我定义的类确实有这两个重载的构造函数，但是网上有些说int型和double型不会构成二义性，即使不构成二义性，但是第二个函数中在返回时应该没有调用这两个重载的构造函数啊。我想问，int和double会不会构成二义性？在我的第二个函数中return时到底是哪里需要调用构造函数了？

他说你调用不明确，你不把调用的代码发上来怎么看

我就是不知道它在哪个地方调用了构造函数啊！必要的代码我都已经附上了，其他的都是无关的代码，都是些理论计算代码了。

根据你的编程思路，我写了和你相同的代码，你可以参照一下：
#include<iostream>
using namespace std;
class a
{
 
public:
       int x;
       double y;
       a(int x1=0,double y1=0):x(x1),y(y1){};
       a operator+(int num);
       a operator+(double num);
       a add(a& a1,a& a2);
       void print(){cout<<"x="<<x<<","<<"y="<<y<<endl;};
 
};
a a::add(a& a1,a& a2)
{
    a a3;
    a3.x=a1.x+a2.x;
    a3.y=a1.y+a2.y;
    return a3;
}
a a::operator+(int num)
{
    a temp(num,0);
    return add(*this,temp);
}
 
a a::operator+(double num)
{
    a temp(0,num);
    return add(*this,temp);
}
 
int main()
{
    a a1(2,3);
    a a2;
    a2=a1+3;//结果a1(2,3)，a2(5,3)  
    a2.print();
    a2=a1+3.5;//结果a1(2,3)，a2(2,6.5)  
    a2.print();
    return 0;
}


不过建议你用下面代码
#include<iostream>
using namespace std;
class a
{
 
public:
       int x;
       double y;
       a(int x1=0,double y1=0):x(x1),y(y1){};
       a operator+(int num);
       a operator+(double num);
       void print(){cout<<"x="<<x<<","<<"y="<<y<<endl;};
 
};
 
a a::operator+(int num)
{
    this->x+=num;
    return (*this);
}
 
a a::operator+(double num)
{
    this->y+=num;
    return (*this);
}
 
int main()
{
    a a1(2,3);
    a a2;
    a2=a1+3;//结果a1(2,3)，a2(5,3)  
    a2.print();
    a2=a1+3.5;//结果a1(2,3)，a2(2,6.5)  
    a2.print();
    return 0;
}

回复 4楼 xufen340：
首先：你能解释一下为什么最好不要直接用this指针吗？
第二：在我的问题里的程序先temp=add(*this,temp);然后 return temp;则不会出现错误（其实这一句也有赋值赋不上的问题）而return add(*this,temp); 这一句为什么会出现调用重载构造函数的错误？ 我不知道这一句怎么会调用构造函数，并没有让它重新生成新的对象啊？即使是它自己自动要求生成一个临时对象，也完全可以调用无参数的构造函数bignum()啊。
第三：重载int型和double型的构造函数应该不会构成二义性吧？
我没法把我的全部代码附上，因为我的代码很多，一个五个文件，很复杂。我想我附上的代码已经可以了，其他的都与问题没关系了，谢谢

首先：你能解释一下为什么最好不要直接用this指针吗？
答：我不明白你的问题，this指针当然可以用，何来不直接用这个说法。
第二：return add(*this,temp); 这一句为什么会出现调用重载构造函数的错误？ 我不知道这一句怎么会调用构造函数，并没有让它重新生成新的对象啊。
答：
return add(*this,temp)这个返回了个临时对象，你是看不到的，但是编译器产生了。这个临时对象如何产生：通过拷贝构造函数产生的。
假如你调用a=a+4;a+4会调用拷贝构造函数返回个临时对象，通过赋值传递给a.所以return add(*this,temp)后编译器会产生个临时对象返回。
比如：
#include <iostream>
#include <string.h>
using namespace std;
class a
{
public:
    a(){cout<<"a construct"<<endl;};
    a(a& aa){cout<<"a copy construct"<<endl;};
    a af1(a aa){return aa;}
};
int main()
{
    a a1;
   a a2=a1.af1(a1);
    int y;
    cin>>y;
}
结果：
a construct
a copy construct
a copy construct
a copy construct
分析：
1.a a1；显示a construct，这个没问题大部分都知道。
2.a1.af1(a1)；显示2个a copy construct，第一个对象传进来给参数a1后调用拷贝构造函数，显示a copy construct，第二个呢，哈哈，就是返回值通过拷贝构造函数产生了一个临时对象，显示a copy construct。
3.a a2=a1.af1(a1)，第四个就是临时对象通过拷贝构造函数拷贝给了a2.
所以return add(*this,temp)不会调用构造函数，只是通过拷贝构造函数拷贝了临时对象。
第三：重载int型和double型的构造函数应该不会构成二义性吧？
当然不会，我在上面的代码已经明确写出了，大概你没看，希望你好好看看。我再举个例子
#include <iostream>
#include <string.h>
using namespace std;
class a
{
public:
    a(int x1):x(x1){cout<<x<<endl;};
    a(double x2):y(x2){cout<<y<<endl;};
    int x;
    double y;
};
int main()
{
    a a1(1);   //调用a(int x1)
    a a2(1.5);//调用a(double x2)
    return 0;
}
第四赋值还是拷贝
上面例子中
1.
a a2=a1.af1(a1);//拷贝
2.
a a2;
a2=a1.af1(a1);//附值