Klassen richtig einbinden header Datei und Methodendefinition getrennt

Prinz Martin

Moin Moin

Ich arbeite gerade diverse Tutorials zu c++ durch und bin jetzt bei den Klassen angelangt. An sich ist OOP für mich nichts neues aber jetzt habe ich ein Problem welches eventuell nur ein Missverständnis mit dem Tutorial ist.

Ich will einfach eine Klasse welche von zwei Integern den kleineren zurück gibt.

Die Headerdatei ist folgende:

class cKleiner
{
  public:cKleiner(int a, int b);
  public:~cKleiner();

  private:int x;
  private:int y;
  private:int erg;

  public:void teste();
  public:int getErg();
};

Die Methodendefinition ist folgende:

#include "cKleiner.h"

cKleiner::cKleiner(int a, int b)
{
  x = a;
  y = b;
}

cKleiner::~cKleiner()
{
}

void cKleiner::teste()
{
  if(x<y)
  {
    erg = x;
    }
    else
    {
    erg = y;
    }
}

int cKleiner::getErg()
{
  return erg;
}

und die main:

#include "cKleiner.cpp"

int main()
{
  cKleiner k(4,5);

  return 0;
}

Und da taucht jetzt das Problem auf. Wenn ich es in der Main so mache mit dem include funktioniert es.

Ich binde die cpp Datei mit der Methodendefinition ein und die bindet ja die headerdatei ein. Im Tutorial stand aber ich behielte die Implementierung der Methoden für mich, da ich mich als Programmierer damit nicht beschäftigen will sondern nur die Eigenschaften und Methoden der Klasse nutzen möchte.

Für mich hört sich das so an, als würde man in der main auch die Kleiner.h Datei einbinden und die holt sich dann die Methodendefinition. Da stellt sich natürlich die Frage, woher sie wissen soll wos die gibt.

Meine Frage ist jetzt also ob ich entweder das Tutorial missinterpretiert und alles richtig gemacht habe weils ja immerhin funktioniert, oder ob ich in der Headerdatei angeben muss, wo sie die Methodendefinition findet.

Ich hoffe ihr versteht mich. (Und könnt helfen ;-))

Grüße
Martin

Neee... In Deinem Hauptprogramm, was die main-Funktion enhält, inkludierst Du nur den Header. Das ist ja gerade der Witz an "separate compilation". Wenn der Compiler dein main-Modul übersetzt, muss er die Definitionen der Funktionen gar nicht kennen. Du kannst die Module einzeln übersetzen und dann mit dem Linker verknoten.

Prinz Martin

also arbeitet mein Hirn doch noch richtig

war mir doch klar, dass das so keinen Sinn macht auch wenns funktioniert.
Aber wieder ein neues Wort gelernt "Linker". Dann werd ich ma gucken wo der bei MinGW versteckt ist bzw was ich wie mit dem mache.

Also grob läuft es so ab:

Methodendefinition schreiben und kompilieren, headerdatei in die main einbinden, per "Linker" die kompilierte Methodendefinition reinwurschteln.

So korrekt?

Dann google ich da ma in die Richtung. (und schieß das Tutorial in die ewigen Jagdgründe) Auch wenn Klassen da schön erklärt werden hätte man auch sagen können, wie die eingebunden werden. Eventuell gehen die wieder von ner IDE aus die das alles komplett selbstständig macht. (Auch ein grund für MinGW, da weiß ich wenigstens am Ende was wann grob passiert).

Grüße
Martin

Prinz Martin schrieb:

... Für mich hört sich das so an, als würde man in der main auch die Kleiner.h Datei einbinden und die holt sich dann die Methodendefinition.

Ja. Kleine Korrektur: In Deiner Headerdatei steht die Definition der Klasse und Deklarationen der Funktionen. Die Definitionen der Funktionen sind nicht notwendig, um dein Hauptmodul zu übersetzen.

Prinz Martin schrieb:

Da stellt sich natürlich die Frage, woher sie wissen soll wos die gibt.

Muss er/sie (?) nicht. Deine Aufgabe ist es, dem Linker zu verraten, wo die Module alle sind, die "gelinkt" werden sollen.

Zum Thema Deklaration und Definition:

class foo;    // Deklaration von foo

class foo     // Definition von foo
{
   static int xxx;   // Deklaration von foo::xxx
   int dings;        // Definition von dings als Datenelement
   void yay() const; // Deklaration von Elementfunktion
};

int foo::xxx = 23;   // Definition

void bar();   // Deklaration

void foo::yay() const {  // Definition
  ...
}

Konzepte, über die Du Dich schlau machen solltest:
- getrennte Übersetzung ("separate compilation")
- Bindung ("linkage")
- ODR ("one definition rule")

Prinz Martin schrieb:

Also grob läuft es so ab:

Methodendefinition schreiben und kompilieren, headerdatei in die main einbinden, per "Linker" die kompilierte Methodendefinition reinwurschteln.

So korrekt?

So in etwa. Das ganze ergibt sich aus der ODR und gesundem Menschenverstand (nach näherem Hinsehen).

Prinz Martin

Joa gut eigentlich machts ja auch nur so wirklich Sinn.

Ich werd mich dann mal schlau machen und dann sehn wa weiter

Danke für die prompte aufklärung.

EDIT:

Das mit der einen Definition war mir schon klar. Da meckerte der in Java schon mal gerne ... is already definded in ....

joa ansonsten ist das erzeugen der objekt datei und das linken ja kein problem mit MinGw. Für die objektdatei hat sogar ein Blick ins g++ --help gereicht ;-).
Und fürs linken braucht man die objektdateien nur hinter die main schreiben die man kompiliert.

Danke für die Hilfe jetzt bin ich schlauer

Grüße
Martin