ich hoffe ihr könnt mir bei meinem KLEINEN problem weiterhelfen.

Ich versuche ( ist eine Aufgabestellung ) einen Operator zu realisieren, der mit natürlichen Zahlen auch funktioniert.

z.B.

int main ()
{
Rechner a, b, c; // a, b, c sind meine Objekte

c = a+b+1;

}

Sobald ich die "1" dort einbringe, bekomme ich die Fehlermeldung
"Es konnte kein Operator gefunden werden, der einen rechtseitigen Operator vom Typ double akzeptiert ( oder kein geeignete konvertierung möglich)"

Ich habe einen zweiten Konstruktor, der diesen Umwandeln sollte nach meinem wissen. In diesem Konstruktor steht nix drin.
Kann jetzt sein , das dieser falsch ist und was fehlt.

Rechner::Rechner( double x )
{

}

Der Standard Konstruktor ist auch vorhanden:

Rechner::Rechner()
{
zahl1 = 1;
zahl2 = 2;
}

Mein Operator sieht so aus:

Rechner operator + ( Rechner & a, Rechner & b )
{
//..........
}
Ich hoffe das ihr mir weiterhelfen könnt.

Danke im voraus.

gruß

musterschüler

Probiere

c = a+b+1.0;

oder überlade

Rechner::Rechner( int x )

kommt immer noch die Fehlermeldung.

Hier mal der gesmate Code:

#include <iostream>
#include "Rational.h"

using namespace std;

void main ()
{
	Rational a,b,c; 
    a.Definiere(3,3);
    b.Definiere(1,3);
    c = a+b+1.0;
}

long ggt (long x, long y )
{
	while ( y )
	{
		long rest = x % y;
		x = y;
		y = rest;
	}

	return x;
}

Rational operator + ( Rational & a, Rational & b )
{
	Rational temp = a;
	return temp += b;
}

#include ".\rational.h"
#include <cassert>

Rational::Rational(void)
{
	zaehler = 1;
	nenner = 1;
}

Rational::Rational( long x )
{
	zaehler = x;
	nenner = 1;
}

Rational::~Rational(void)
{
}

long Rational::Zaehler(void)
{
	return zaehler;
}

long Rational::Nenner(void)
{
	return nenner;
}

Rational& Rational::operator += (Rational & x)
{
	zaehler = zaehler * x.nenner + nenner * x.zaehler;
	nenner = nenner * x.nenner;

	Kuerzen();

	return *this;
}
void Rational::Kehrwert(void)
{
	long temp = zaehler;
	zaehler = nenner;
	nenner = temp;
	assert(nenner != 0);
}

void Rational::Kuerzen(void)
{
	int sign = 1;

	if ( zaehler < 0 )
	{
		sign = -sign;
		zaehler = -zaehler;
	}
	if ( nenner < 0 )
	{
		sign = -sign;
		nenner = -nenner;
	}

	long teiler = ggt( zaehler, nenner );

	zaehler = sign * zaehler / teiler;
	nenner = nenner / teiler;
}

void Rational::Definiere(long z, long n)
{
	zaehler = z;
	nenner = n;
	assert(nenner != 0);
	Kuerzen();
}

Ich habe gelesen, das durch die schreibweise:

c = a+b+[b]1.0[/b];

für 1.0 ein temp Objekt automatisch erzeugt wird.
Leider klappt es net.

Gruß

Musterschüler

PS: Vorab ein dank von mir.

Gruß

Du hast nur eine Konstruktor der einen long-Wert nimmt. Damit der Compiler aber deinen Wert automatisch umwandeln kann benötigst du einen für Integers / Doubles. [Oder du schreibst + 1l]

Gruß

das ist nicht das problem. aber seine operatoren nehmen referenzen auf nicht-const... da werden nat. keine temporaries erzeugt.