//#include "rational.h"
//Deklarieren von Includes + Klassen
#include<iostream>
#include<stdlib.h>
#include<stdio.h>

using namespace std;

class Ratio 
{
private:

	    int m_zaehler;
		int m_nenner;
public:

	 Ratio(int zaehler,int nenner)//Konstruktor
   {
      m_zaehler=zaehler;
      m_nenner=nenner;
   };
//vorgegebene Methoden
	void Multiplikation (const Ratio r);
	void Addition (const Ratio& r);
	void Substraktion (const Ratio& r);
	void Division (const Ratio& r);
	void Kehrwert ();
	void Ausgabe()
{
	cout<<m_zaehler<<'/'<<m_nenner<<endl;
}
	void Eingabe  ();
}; 
typedef class Ratio r;

void main ()
{

	Ratio a(100,400);

	cout<<"a=";
	a.Ausgabe();
	cout<<endl;
system ("pause");
}

void Multiplikation ( r)
{
	int z,n;
	z=r.zaehler;
	return result;
}

Du deklarierst hier ganix, du inkludierst Standard-Header

#include<stdio.h>

Wofür das?

using namespace std;

Nicht so gut. Informier dich mal, findest zahlreiche Threads...

Ratio(int zaehler,int nenner)//Konstruktor
   {
      m_zaehler=zaehler;
      m_nenner=nenner;
   };

Bitte initialisierungs-liste

//vorgegebene Methoden
    void Multiplikation (const Ratio r);
    void Addition (const Ratio& r);
    void Substraktion (const Ratio& r);
    void Division (const Ratio& r);
    void Kehrwert ();

Zahlreiche undefinierte Methoden...

cout<<m_zaehler<<'/'<<m_nenner<<endl;

Bisschen schöner formatieren büdde

void Eingabe  ();

Nicht definiert

typedef class Ratio r;

WHAT THE

void main ()

Nicht erlaubt, main must return int :p

cout<<"a=";
    a.Ausgabe();

Ausgabe-Operator überladen (alles im netz)?

system ("pause");

Och ney, ne (alles im netz)?

}

void Multiplikation ( r)
{
    int z,n;
    z=r.zaehler;
    return result;
}

WHAT THE F

Edit: Lieber wieheisstdunochmalichhabekeinelustdenthreadnochmalzuöffnenweilichgradeeditiere,

viele der Oben genannten Stichwörter kannst du im Netz (MANCHMAL) mit guter Erklärung finden, wie Operatoren-Überladung (siehe pumuckls schönen Artikel), Initialisierungs-Listen und OOP im allgemeinen, sieh dir auch nochmal sowas wie typedefs an (denn anscheinend fehlst du weit an deren eigentlicher Funktion vorbei).

MfG

class Bruch
{
	private:
		int zaehler;
		int nenner;

	public:
		Bruch(int zaehler_, int nenner_=1);
		Bruch();
		int get_nenner() const {return nenner;};
		int get_zaehler() const {return zaehler;};
};

so sollte ungefähr deine Klasse aussehen, denn bei dir fehlen getter, um denn Nenner und den Zaehler auszulesen.
und hier die definition einer funktion zum Addieren
[/cpp]

Bruch addiere(const Bruch& lhs, const Bruch& rhs){
    int lokal_nenner=lhs.get_nenner+rhs.get_nenner;
    int lokal_zaehler=lhs.get_zaehler+rhs.get_zaehler;

    return Bruch(lokal_zaehler, lokal_nenner);
}

das machst du analog zu allen anderen.

Wie kann man z.B. Brüche eingeben, und wie kann man Zähler und Nenner in die methode ausserhalb der klasse schicken und einen return erhalten? wäre um jede Hilfe dankbar

Dir ist das Prinzip von Klassen und Objekten wirklich nicht bewusst, ebenso wie fehlende Einrückungen etc.

#include<iostream>
#include<cstdlib>
#include<cstdio>

using namespace std; // Bitte sobald man in Header und Source trennt dies niemals
                     // Im Header, und nur hinter allen Includes.

class Ratio 
{
  private:
    int m_zaehler;
    int m_nenner;

  public:
    Ratio(int zaehler,int nenner) //Konstruktor <-- Solche Kommentare sind irgendwie sinnlos.
    : m_zaehler(zaehler), m_nenner(nenner) // <-- Dies ist eine Initialisierung (Initialisierungsliste des Konstruktors)
    {
      m_zaehler=zaehler; // <-- Dies ist eine Nachträgliche Zuweisung
      m_nenner=nenner;
    };

    //vorgegebene Methoden
    void Multiplikation (const Ratio r); // <-- Sicher das hier keine Referenz (&) übergeben wird?
    void Addition (const Ratio& r);
    void Substraktion (const Ratio& r);
    void Division (const Ratio& r);
    void Kehrwert ();
    void Ausgabe()
    {
        // Oben lässt du viel Abstand, und hier hängst du alles auf
        // Engsten Raum? "cout<<m_z..."?
        cout << m_zaehler << '/' << m_nenner << endl;
    }

    void Eingabe();
}; 

int main() // void main existiert nicht, und war noch nie legales C++
{
  Ratio a(100,400);
  cout << "a=";
  a.Ausgabe();
  cout << endl;
  system("pause");
}

// Hier fehlt die Klasse, die Parameterliste...
//void Multiplikation ( r)
//      /-- Gehört zu der Klasse Ratio
//      |      /-- Methode Multiplikation der Klasse
void Ratio::Multiplikation(const Ratio r) // <-- Gleiche Parameter wie in der Klasse verwenden
{
    // Da Bestandteil der Klasse kannst du hier m_zaehler & m_nenner des
    // Objektes, sowie gleiches bei dem übergebenen Parameter verwenden,
    // obwohl private:
    //
    // m_nenner    m_nenner des aktuellen Objektes
    //             Alternativ: this->m_nenner
    // r.m_nenner  m_nenner des übergebenen Objektes

    // return result; <-- Die Methode hat void als Rückgabe, sie ändert nur
    // m_nenner und m_zaeher des aktuellen Objektes - Daher kein Return
}