转换构造函数不会将“2”转换为运算符 + 中的用户定义类型答案

【问题标题】：Conversion constructor won't convert "2" into user-defined-type in operator +转换构造函数不会将“2”转换为运算符 + 中的用户定义类型
【发布时间】：2011-08-31 06:48:10
【问题描述】：

我有一个名为 Fraction 的课程：

#ifndef FRACTION_H
#define FRACTION_H

#include <iostream>
using namespace std;

class Fraction
{
  // data
  int m_iNom;
  int m_iDenom;

  // operations
  int gcd (int i, int j);
  void reduce ();

public:

 Fraction (int nn=0, int dn=1); // 1 declaration = 3 constructors
 Fraction (const Fraction& fr); //C.Ctor
 ~Fraction (); //Dtor
 Fraction& operator = (const Fraction &fr); //assignment

 Fraction& operator ++ (); // prefix - ++a
  const Fraction operator ++ (int); // postfix - a++

  friend const Fraction operator + (const Fraction &f1, const Fraction &f2);
  friend const Fraction operator - (const Fraction &f1, const Fraction &f2);
  friend const Fraction operator * (const Fraction &f1, const Fraction &f2);
  friend const Fraction operator / (const Fraction &f1, const Fraction &f2);

 Fraction& operator += (const Fraction &f);

  operator double () { return double (m_iNom) / m_iDenom; } //casting operator

  friend istream& operator >> (istream &is, Fraction &f);
  friend ostream& operator << (ostream &os, const Fraction &f);
  const int& operator[] (int i) const;
  int& operator [] (int i);


};
#endif

下一个实现文件：

#include "Fraction.h"
#include <iostream>
using namespace std;


Fraction::Fraction (int nn, int dd) :
   m_iNom (nn), m_iDenom (dd) {
  if (m_iDenom == 0)
  m_iDenom = 1;
 reduce ();
 cout<<"Ctor - Fraction: "<<m_iNom<<"/"<<m_iDenom<<endl;
}


Fraction::Fraction (const Fraction & fr){
 m_iNom=fr.m_iNom;
 m_iDenom=fr.m_iDenom;
 cout<<"C.Ctor - Fraction: "<<m_iNom<<"/"<<m_iDenom<<endl;
}

Fraction::~Fraction() {
 cout<<"del: "<<m_iNom<<"/"<<m_iDenom<<endl;
}


int Fraction::gcd (int i, int j) {
  if ((i == 0) || (j == 0))
   return i + j;
  while (i %= j) {
   int t = i;
  i = j;
  j = t;
 }
  return j;
}


void Fraction::reduce () {
  int g = gcd (m_iNom, m_iDenom);
 m_iNom /= g;
 m_iDenom /= g;
}


const Fraction operator + (const Fraction &f1, const Fraction &f2) {
  int nn = f1.m_iNom * f2.m_iDenom + f1.m_iDenom * f2.m_iNom;
  int dd = f1.m_iDenom * f2.m_iDenom;
  return Fraction (nn, dd);
}


const Fraction operator - (const Fraction &f1, const Fraction &f2) {
  int nn = f1.m_iNom * f2.m_iDenom - f1.m_iDenom * f2.m_iNom;
  int dd = f1.m_iDenom * f2.m_iDenom;
  return Fraction (nn, dd);
}


const Fraction operator * (const Fraction &f1, const Fraction &f2) {
  int nn = f1.m_iNom * f2.m_iNom;
  int dd = f1.m_iDenom * f2.m_iDenom;
  return Fraction (nn, dd);
}


const Fraction operator / (const Fraction &f1, const Fraction &f2) {
  int nn = f1.m_iNom * f2.m_iDenom;
  int dd = f1.m_iDenom * f2.m_iNom;
  return Fraction (nn, dd);
}


Fraction& Fraction::operator = (const Fraction &f)
{
 m_iNom = f.m_iNom;
 m_iDenom = f.m_iDenom;
 cout<<"OP = - Fraction: "<<m_iNom<<"/"<<m_iDenom<<endl;
  return *this;
}


Fraction& Fraction::operator += (const Fraction &f) {
 (*this) = (*this) + f;
  return *this;
}


Fraction& Fraction::operator ++ ()
{
 m_iNom += m_iDenom;
 reduce ();
  return *this;
}


const Fraction Fraction::operator ++ (int)
{
  int nn = m_iNom;
  int dd = m_iDenom;
 m_iNom += m_iDenom;
 reduce ();
  return Fraction (nn, dd);
}


istream& operator >> (istream &is, Fraction &frac)
{
  char divSign;
 is >> frac.m_iNom >> divSign >> frac.m_iDenom;
  if (frac.m_iDenom == 0)
  frac.m_iDenom = 1;
 frac.reduce ();
  return is;
}


ostream& operator << (ostream& os, const Fraction &frac)
{
  return os << frac.m_iNom << "/" << frac.m_iDenom;
}


int& Fraction::operator [] (int i){
 cout<<"reg []"<<endl;
  if (i==1)
   return m_iNom;
  return m_iDenom;
}


const int& Fraction::operator[] (int i) const{
 cout<<"const []"<<endl;
  if (i==1)
   return m_iNom;
  return m_iDenom;
}

我正在尝试执行操作 Fraction f4=f2+2; 但我收到以下编译器错误：

..\main.cpp:13: error: ambiguous overload for 'operator+' in 'f2 + 2'
..\main.cpp:13: note: candidates are: operator+(double, int) <built-in>
..\Fraction.h:27: note:                 const Fraction operator+(const Fraction&, const Fraction&)

但是怎么可能呢，如果我有一个转换构造函数（请注意 .h 文件中的 Ctor 具有默认值），其中一个参数是假设将“2”转换为分数......那么是什么可能是问题所在？

谢谢罗南

编辑：

这是主文件（如果有帮助的话）

#include <iostream>
using namespace std;

#include "Fraction.h"

int main() {
    Fraction f1(1,2);
    Fraction f2(2);
    Fraction f3;

    Fraction f4=f2+2;  // problem's here 
    f2+f2;
    Fraction f5=f2-f1+f4;
    return 0;
}

【问题讨论】：

问了 12 个问题，没有一个答案被接受！！
我没看懂你的意思……

标签： c++ casting operator-overloading overloading

【解决方案1】：

编译器无法决定是将f2转换为double然后添加double和int，还是从2构造Fraction然后添加两个分数。

选项：

使运算符 double() 显式 (C++11)
重载运算符 + 以获取整数

【讨论】：

【解决方案2】：

问题是：

operator double ()

在您的 Fraction 类中定义。

在评估时，

Fraction f4=f2+2;

编译器有两种选择：

首选：

编译器可以使用您提供的运算符函数将f2 转换为double，然后可以使用它来调用内置的运算符函数：

    operator+(double, int);

第二选择：

编译器可以使用构造函数将2转换为Fraction的对象，然后调用：

const Fraction operator+(const Fraction&, const Fraction&)

这两个选择会导致歧义，然后编译器会抱怨并向您报告。

解决方案：
更改double 运算符函数的名称。

【讨论】：

其他解决方案包括： 1. 如果您使用的是 C++0x 编译器，则使 double() 运算符显式化。 2. 添加运算符+(const Fraction&, double)。可能还有其他人......
@Michael：解决方案 3：不要使用没有 explicit 的转换运算符（这意味着在 C++0x 之前不使用它们）。

【解决方案3】：

当您编写类似f2+2 的内容时，编译器确实可以做出两种选择。

它可以先使用分数的构造函数将2转换为分数，然后使用分数的+运算符。
它可以先使用Fraction的double运算符将f2转换为double，然后简单地将double和整数相加

您必须使构造函数显式，或为双运算符指定显式名称（例如 toDouble）来解决问题。

【讨论】：