mein Debugger meckert und ich weiß nicht wieso. Hier die Header:

#include <iostream>

class Bruch	
{ 
private:
	int m_z;
	int m_n;

public:
	Bruch();
	Bruch(int zaehler, int nenner);
	void eingabe();
	void ausgabe();
	int operator=(Bruch &a, const Bruch &b);
	friend Bruch operator ~(Bruch u);
	friend Bruch operator+(const Bruch &u, const Bruch &v);
	void operator+=(Bruch &f, const Bruch &g);
	friend Bruch operator*(const Bruch &j, const Bruch &k);
	void operator*=(Bruch &d, const Bruch &e);
	friend Bruch operator/(const Bruch &o, const Bruch &r);
	friend Bruch operator-(const Bruch &u, const Bruch &v);
};

Und die Funktionen.cpp:

#include <iostream>
#include <Bruch (decl).h>
using namespace std;

Bruch::Bruch()
:m_z(0), m_n(0)
{};

void Bruch::Bruch(int zaehler, int nenner)  //class::constructor()
:m_z(zaehler), m_n(nenner) 
{};

void Bruch::eingabe()
{cout << "Zähler:\t"; while(!(cin >> m_z));
 cout<<"\n\nNenner:\t"; while(!(cin >> m_n)); cout << "\n\n\n";
};

void Bruch::ausgabe()				    //class::method
{cout << "\n\nBruch:" << m_z << "/" << m_n << "=" << (double) m_z/m_n << endl;};

int Bruch::operator=(Bruch &a, const Bruch &b)
{
	if (a.m_z=b.m_z && a.m_n=b.m_n) return EXIT_SUCCESS;
	else							return EXIT_FAILURE;
};

Bruch operator ~(Bruch u) //Kehrwert; muss als friend gelistet sein
{
	return(Bruch(u.m_n, u.m_z)); //”anonyme” Hilfsvar
};
/* Bsp. für Aufruf: Bruch x(1,2), y(3,4); x = ~y 

// → x.m_z=4 //==y.m_n;  
// → x.m_n=3 //==y.m_z   */

Bruch operator+(const Bruch &u, const Bruch &v) //friend Funktion von class Bruch
{
	return(Bruch( (u.m_z*v.m_n)+(u.m_n*v.m_z) , u.m_n*v.m_n) );
};

void Bruch::operator+=(Bruch &f, Bruch const &g) //Methode
{
	f.m_z += g.m_z;
	f.m_n += g.m_n;
};

Bruch operator*(const Bruch &j, const Bruch &k) //friend Funktion von class Bruch
{
	return(Bruch( (j.m_z*k.m_z) , (j.m_n*k.m_n) ));
};

void Bruch::operator*=(Bruch &d, const Bruch &e) //Methode
{
	d.m_z *= e.m_z;
	d.m_n *= e.m_n;
};

Bruch operator/(const Bruch &o, const Bruch &r) //friend Funktion von class Bruch
{
	return(Bruch( (o.m_z*r.m_n) , (o.m_n*r.m_z) ));
};

Bruch operator-(const Bruch &u, const Bruch &v) //friend Funktion von class Bruch
{
	return(Bruch( (u.m_z*v.m_n)-(u.m_n*v.m_z) , u.m_n*v.m_n));
};

Die Fehlermeldungen lauten bspw.:

.../Bruch (decl).h:21:0 .../Bruch (decl).h:21: error: 'int Bruch::operator=(Bruch&, const Bruch&)' must take exactly one argument

//Aber für ne Zuweisung brauche ich doch zwei Exemplare/ Parameter

/.../Bruch (func).cpp:13:0 .../Bruch (func).cpp:13: error: 'Bruch' has not been declared

.../Bruch (func).cpp:13:0 .../Bruch (func).cpp:13: error: ISO C++ forbids declaration of 'Bruch' with no type

.../Bruch (func).cpp:14:0 .../Bruch (func).cpp:14: error: only constructors take base initializers

.../Bruch (func).cpp:17:0 .../Bruch (func).cpp:17: error: 'Bruch' is not a class or namespace

.../Bruch (func).cpp:22:0 .../Bruch (func).cpp:22: error: 'm_z' was not declared in this scope

.../Bruch (func).cpp:23:0 .../Bruch (func).cpp:23: error: 'm_n' was not declared in this scope

.../Bruch (func).cpp:29:0 .../Bruch (func).cpp:29: error: declaration of 'operator=' as non-function

.../Bruch (func).cpp:29:0 .../Bruch (func).cpp:29: error: 'a' was not declared in this scope

.../Bruch (func).cpp:29:0 .../Bruch (func).cpp:29: error: expected primary-expression before 'const'

.../Bruch (func).cpp:35:0 .../Bruch (func).cpp:35: error: expected constructor, destructor, or type conversion before 'operator'

.../Bruch (func).cpp:44:0 .../Bruch (func).cpp:44: error: expected constructor, destructor, or type conversion before 'operator'

Und diese scope errors versteh ich auch nicht, habe doch Bruch (decl).h includiert.
Kann mir jemand sagen wo der Haken ist?

Danke
MfG

Mach das Leerzeichen raus und nimm "".

#include "Bruch.h"

"" und <> sind 2 unterschiedliche Scopes an Verzeichnissen.

edit:
Die Ausgabe kann man btw schöner machen:

#include <iostream>
#include <ostream>

class Bruch
{
public: 
    Bruch() : a(2) {}
    int a;
    friend std::ostream& operator<<(std::ostream& s, Bruch& b);
};

std::ostream& operator<<(std::ostream& s, Bruch& b)
{
   s << "Ergebnis: " << b.a;   
   return s;
}

int main()
{ 
    Bruch a;
    std::cout << a;
}

rya.

Was du eigentlich machen willst ist sowas hier? (Kopieren von Objekten)

class Bruch{
...
void swap(Bruch& rhs); //tausche *this und rhs Daten
...
};

Bruch& Bruch::operator=(Bruch rhs)
{
swap(rhs);
return *this;
}

"Pass by Value" kann hier schnell sein als die Alternative:

Bruch& Bruch::operator=(const Bruch& rhs)
{
Bruch temp(rhs);
swap(temp);
return *this;
}

EDIT: Was du versucht hast geht so:

//classA.h
class Bruch
{
public:
	int a;
	int b;

	Bruch(int aa, int bb): a(aa), b(bb){}

	int operator = (const Bruch& rhs);

};

//classA.cpp
#include "classA.h"

int Bruch::operator = (const Bruch& rhs)
{
	if (rhs.a == this->a && rhs.b == this->b) return 1;
	else return 2;
}

//main.cpp
#include <iostream>
#include "classA.h"

using namespace std;

int main()
{
	Bruch a(1,2);
	Bruch b(3,4);
	Bruch c(1,2);

	cout << (a = b) << endl;
	cout << (b = c) << endl;
	cout << (c = a) << endl;

	cin.get();
	cin.get();

	return 0;
}

Hoffe das hilft cu.

Bruch& Bruch::operator=(Bruch x)
{
swap(x)

swap(x), tausche x WOMIT? Zuweisung ist doch nicht unär ? Irgendwas versteh ich falsch

der letzte post wurde vor deinem edit verfasst, daher hier der Nachtrag..

Gute nacht

Ich kenne this noch nicht ausreichend, um deinen Code richtig zu verstehen. Setze mich morgen dran.

"this" ist einfach ein Zeiger auf sich selbst (Die Instanz der Klasse). Du kannst this-> auch weglassen, sofern die Bezeichner eindeutig sind.

Beispiel:

class A
{
    private:
        int a;
    public:
        void test1(int b);
        void test2(int a);
};

void foo()
{
    // foo gehört nicht zu einer Instanz, hat daher kein this.
}

void A::test1(int b)
{
    a = b;
    // oder
    this->a = b; // a ist eine Instanzvariable, und auch über this->
                 // erreichbar
}

void A::test2(int a)
{
    // hier überdeckt der Parameter a, den Namen der Instanzvariable,
    // "a" wäre hier der Parameter. Hier benötigst du this-> um eindeutig
    // zu sagen, das du die Instanzvariable meinst.
    this->a = a;
    //  |     \__ Parameter a
    //  \__ Instanzvariable a
}