// ratio.cpp 
#include"ratio.h"
#include<iostream>
#include<assert.h>

rational::rational(long ganz)       // Typumwandlungskonstruktor
{
    zaehler = ganz;
    nenner = 1;
                        }

void rational::add(rational a, rational b) //Beispielfunktion
{
     zaehler = a.zaehler*b.nenner + b.zaehler*a.nenner;
     nenner  = a.nenner*b.nenner;
     kuerzen();
     }

// ratio.h
// Klasse für rationale Zahlen
#ifndef ratio_h
#define ratio_h

class rational
{

      public:
             rational()
             : zaehler(1), nenner(1)
             {}                     //inline
             rational(long);        //Typumwandlungskonstroktor

             // Abfrage inline
             long Zaehler () const {return zaehler;}
             long Nenner () const {return nenner;}

Dann habe ich ein weiteres Problem:
Ich möchte eine public member-Funktion zu einer private Funktion machen. Wie genau stelle ich das an klappt anscheinend nicht wenn ich private vorschreibe und das in der header-Datei unter private deklariere.

// ratio.h
// Klasse für rationale Zahlen
#ifndef ratio_h
#define ratio_h

class rational
{

      public:
      // hab hier was ausgelassen

      private:
               friend rational operator+(rational, rational); 
               long zaehler, nenner;
    };
    #endif

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

void rational::kuerzen()
{
     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;
}

Die kuerzen -Fubnktion soll private werden. So hoffe habe euch nicht erschlagen mit den Fragen und ihr könnt mir Helfen.

MFG Carlos

carlosmexiko schrieb:

Hallo, habe eine Klasse und ein cpp-Funktion namens rational.

Was verstehst du unter einer cpp-Funktion? Meinst du eine cpp-Datei? Ich seh zumindest keine Funktion die rational heißt.

In der cpp-Funktion hab ich nen Konstruktor eingebaut. Das ist aber ein Typumwandlungskonstruktor. Wie genau bekomme ich den in eine Standard-default-konstruktor umgewandelt, sodass meine Funktion mit zwei Argumenten aber auch ganz ohne auskommen.
Hab schon probiert das long ganz wegzulassen und stattdessen ne leere Klammer zu haben. Und dann zaehler=1 zu schreiben, dann hab ich aber das Problem das ich in der header-file und im cpp-Teil das gleiche habe. Und eins weglassen geht auch nich so einfach.

Wie meinen? was hast du probiert? Wenn du das long weglässt, hast du einen default-Konstruktor. Und der hat keine Argumente. Mit zwei Argumenten wäre es kein default-Konstruktor. Und du solltest auf jeden Fall die Funktionen die du im Header deklarierst in der cpp-Datei auch definieren. In beidem das gleiche zu haben ist also genau richtig und nicht ein Problem. oder was meintest du?
Wenn du dein Objekt mit zwei oder garkeinem Argument konstruieren können willst brauchst du halt zwei Konstruktoren. Oder du machst default-Argumente, dann kannst du den selben Konstruktor für die Konstruktion mit 0, einem und zwei Argumenten benutzen.

Dann habe ich ein weiteres Problem:
Ich möchte eine public member-Funktion zu einer private Funktion machen. Wie genau stelle ich das an klappt anscheinend nicht wenn ich private vorschreibe und das in der header-Datei unter private deklariere.

Doch das klappt. Zeig uns den Code mit dem du es versucht hast, dann kann man dir auch sagen was falsch dran ist.

Die kuerzen -Fubnktion soll private werden.

Dann schreib sie in den private-Teil in der Klasendeklaration im header, so wie du gesagt hast.

long ggt(long x, long y) // Hilfsfunktion für kuerzen()
{
     while (y)
     { long rest = x % y;
      x=y; y=rest;
      }
      return x;
}

private void rational::kuerzen()
{
     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;
}

Und in der header-Datei:

private:
               void kurzen();
               long zaehler, nenner;

MFG Carlos

Genau ich brauch nen Konstruktor, denn ich mit zwei aber auch ganz ohne Argumente nutzen kann.

Wie bei jeder anderen Funktion, kannst du default Werte folgendermaßen angeben:

int foo(int val1 = 5, int val2 = 10);

foo(); // val1 = 5, val2 = 10
foo(2); // val1 = 2, val2 = 10
foo(2, 1); // val1 = 2, val2 = 1

MfG,
ScRaT

class myClass
{
  public:

    myClass(int a=0, int b=0); /
    ....
};

In der definition brauchst du die belegung nicht mit zu übernehmen.
die kommt nur in die deklaration, jetzt kannst du dann Konstruktor sowohl ohne als auch mit argumenten verwenden!

Gruß

ich mit zwei aber auch ganz ohne Argumente nutzen kann

Schreib zwei Konstruktoren, nennt sich Ueberladung. Das funktioniert auch bei allen anderen Funktionen/Methoden. Ich persoenlich halte nicht viel von default-Parametern.

Habe das mit der private Funktion wie folgt probiert:
In der cpp-Datei: [...]

in der cpp-Datei gehören die Zugriffspezifizierer nicht hin, d.h. lass das private dort weg (da dürfte dir der Compiler auch eine entsprechende Fehlermeldung zu gegeben haben, die sollte man immer aufmerksam lesen!) So wie du es im Header gemacht hast ists richtig. Sollte aber auch in jedem Tutorial so zu finden sein.

SocketMaster schrieb:

Wenn du einen Konstruktor mit und ohne Argumenten benutzen willst, muss in der Klassen deklaration den Konstruktor vorbelegen mit 0

Das klingt so als ob default-argumente immer 0 sein müssten, was natürlich nicht stimmt. Gerade bei einem rational-Konstruktor würde ich das default-argument für den Nenner 1 machen, für den Zähler 0. Damit wird beim default-Ctor ein rational-Objekt mit 0/1, also 0 initialisiert (so wie die eingebauten Datentypen auch), und wenn man ein argument angibt entspricht das dem entsprechenden int, so dass man einen Umwandlungs-Konstruktor hat der genau das tut was man erwartet.

knivil schrieb:

Ich persoenlich halte nicht viel von default-Parametern.

Das ist persönlicher Geschmack, in dem Fall tun aber default-Parameter nichts böses und sparen Schreibarbeit bzw. Code-Duplikation.

MFG Carlos

rational operator+(rational a, rational b)
{
         rational t;
         t.zaehler = a.zaehler*b.nenner + b.zaehler*a.nenner;
         t.nenner  = a.nenner*b.nenner;
         t.kuerzen();
         return t;
}

Kommt dieser Teil in die header-Datei? Und wie Implementier ich das dann in meiner CPP-Datei?

Was mich daran stört ist das ich nur eine Zahl eingeben möchte. Da könnte ich doch statt a.zaehler zaehler und statt a.nenner nenner schreiben, oder? Damit mein Konstruktor einspringt.

MFG Carlos

Das ganze in eine .cpp auszulagern funktioniert genau gleich, wie bei allen anderen Funktionen auch. operator + ist ja eigentlich nur ein Name, der ein wenig eine schönere Syntax ermöglicht. Einfach im Header deklarieren und dann kannst du die Funktion in der .cpp definieren.