Dotaz: problem s gcc

[secido]

Tento kod mi so starsou verziu gcc fungoval:

Fraction::Fraction(int znum, int zden) {
num = znum;
den = zden;
normalize();
}

Fraction::Fraction(double f) {
num = int(f) * 10000;
num += int((f - int(f))*10000.0);
den = 10000;
normalize();
}

Fraction Fraction::operator+(Fraction b) {
return Fraction(den*b.num+b.den*num, den*b.den);
}

...

c4=-.5+c1

Teraz s pouzitim gcc 4.0.3 dostanem chybu:

no match for ‘operator+’ in ‘-5.0e-1 + c1’

Po takejto uprave to chodi:

c4=Fraction(-.5)+c1

V com je problem? Nemal by sa implicitne pouzit konstruktor Fraction(double)?

Odpovědi

[Michal Kubeček]

Aby vám tohle prošlo, musel byste použít samostatný operátor, ne metodu. Tedy např.:

inline Fraction operator + (const Fraction& x, const Fraction& y)
{
  return Fraction(x.den*y.num+y.den*x.num, x.den*y.den);
}

[secido]

Skusal som to pridat, ale den a num su private. Radsej uvediem kompletny kod. Trochu som cvicil s C++ pred par rokmi no daleko som sa nedostal, teraz som znovu dostal chut .

fraction.h:
#ifndef FRACTION_H
#define FRACTION_H

#include <iostream>

using namespace std;

class Fraction
{
    int num, den;

    int gcd(int, int);

    public:

    Fraction(int = 0, int = 1);
    Fraction(double);
    Fraction(const Fraction&);
    void normalize();
    Fraction operator+(const Fraction&);
    Fraction operator-();
    Fraction operator-(const Fraction&);
    Fraction operator*(const Fraction&);
    Fraction operator/(const Fraction&);
    const int numerator() const;
    const int denominator() const;
    friend ostream& operator<<(ostream& os, const Fraction& z);
    friend istream& operator>>(istream& is, Fraction& z);
    const double toDouble() const;
};
#endif

fraction.cpp:
#include "fraction.h"

int Fraction::gcd(int a, int b) {
  int c = 1;
  a = (a >= 0) ? a : - a;
  b = (b >= 0) ? b : - b;
  while (c > 0) {
    c = a % b;
    a = b;
    b = c;
  }
  return a;
}

Fraction::Fraction(int znum, int zden) {
  num = znum;
  den = zden;
  normalize();
}

Fraction::Fraction(const Fraction& z):num(z.num), den(z.den) {
  cout << "Fraction(const Fraction&) : " << *this << endl;
}

Fraction::Fraction(double f) {
  num = int(f) * 10000;
  num += int((f - int(f))*10000.0);
  den = 10000;
  normalize();
}

void Fraction::normalize() {
  int lgcd = gcd(num, den);
  num /= lgcd;
  den /= lgcd;
}

Fraction Fraction::operator+(const Fraction &b) {
  return Fraction(den*b.num+b.den*num, den*b.den);
}

Fraction Fraction::operator-() {
  return Fraction(-num, den);
}

Fraction Fraction::operator-(const Fraction& b) {
  return Fraction(b.den*num-den*b.num, den*b.den);
}

Fraction Fraction::operator*(const Fraction& b) {
  return Fraction(num*b.num,den*b.den);
}

Fraction Fraction::operator/(const Fraction& b) {
  return Fraction(num*b.den, den*b.num);
}

const int Fraction::numerator() const {
  return num;
}

const int Fraction::denominator() const {
  return den;
}

ostream& operator<<(ostream& os, const Fraction& z) {
  if(z.den == 1)
    return os << z.num;
  else
    return os << z.num << "/" << z.den;
}

istream& operator>>(istream& is, Fraction& z) {
  char c;
  is >> z.num;
  is >> c;
  is >> z.den;
  return is;
}

const double Fraction::toDouble() const
{
  return double(num)/double(den);
}

fractest.cpp:
#include <iostream>
#include "fraction.h"

#define P(x) cout << "[" #x "] = " << (x) << endl;

/*
inline Fraction operator+(const Fraction& x, const Fraction& y) {
  return Fraction(x+y);
}
*/


int main()
{
    Fraction c1(12,123);
    Fraction c2(98);
    Fraction c3(0,1);
    Fraction* c5 = new Fraction(2,3);

    P(c1); P(c2); P(c3); P(*c5);

    P(c3=c1+c2);
    P(c3=c1-c2);
    P(c3=c1*c2);
    P(c3=c1/c2);
    P(*c5=c1+c2+c3);
    P(c3=c1+c2/c3-c1);
    P(c3=(c1+c2)/(c3-c1));

    Fraction c4 = c3;
    P(c4);
    P(c4=c1+5+5.5);
    P(c4=7);
    P(c4=-.5);
    P(c4=c4+c1);
    P(c4=Fraction(-.5)+c1);
//    P(c4=-.5+c1);
    P(c4=c1-.5);
    P(c4.toDouble());
//    P(double(c4));

    delete c5;
    return 0;
}

[Michal Kubeček]

Jestli je problém jen v tom, že jsou private, tak buď v implementaci operátoru použíjte přístupové metody numerator() a denominator() nebo ten operátor deklarujte jako friend.

Mimochodem, z logiky věci by asi metodu gcd() bylo v tomto případě vhodnější deklarovat jako static.