3. Wie verwendet man die Klassen

Wie verwendet man die Klassen

  • S

    Ich bin mir da nicht so ganz sicher, weil es in meinem Buch nicht exakt erwähnt
    wird, schreib ich ne Klasse nun so:

    class foo {
    private:
        int * bar () {
            count << "foo";
            static int f = 1;
            return &f;
        }
};

    Oder so:

    class foo {
    private:
        int * bar ();
};
// Und darunter dann
foo::bar () {
     count << "foo";
     static int f = 1;
     return &f; 
}

    Oder geht beides?

    0
  • ?

    Hi,

    SirLant schrieb:

    Oder geht beides?

    jepp, beides müsste gehen.
    Der vorteil vom unteren ist halt das du die Klasse und deren Methode vor der main function definierst und erst später dann schreibst was sie tuen soll,
    wie mit Funktionsprototypen.

    Bin mir aber auch nicht sicher ob ich das richtig verstanden habe.

    cu max

    0
  • ?

    Die erste Methode ist damit auch implizit inline.

    0
  • R
     

    int * bar () { 
  count << "foo"; 
  int f = 1; 
  return &f; 
}

    und nun lies mal in deinem lieblings C++-Buch etwas über Scopes und "Lebenszeiten" von Variablen nach

    http://www.c-plusplus.net/forum/viewtopic.php?t=39474
    http://tutorial.schornboeck.net/scope.htm

    0
  • S

    Das war doch nur nen Beispiel um die Klassen zu demonstrieren, dass man lokale
    Variablen nicht zurückgeben soll ist mir klar. Außer man verwendet static

    0
  • K

    ich finde, man sollte die implementierungen der funktionen grundsätzlich in eine andere datei auslagern. das schafft übersicht, man kann z.b. anderen entwicklern die headerdatei geben, und die wissen bescheid (ähnlich den interfaces bei java, die find ich wirklich sinn machen) ohne die implementierung zu wissen. willst du immer noch eine funktion inline machen, so kennzeichnest du sie mit inline.

    0
  • W

    ...

    0
  • ?

    @Korbinian kann dir nur zustimmen 👍 Code-Design ist ein halbes Lebe.. ähhh Programm! 😃

    0
  • S

    Ok danke, frage mich gerade nur weshalb es ein Buch (genaugenommen sogar 2) nicht
    schafft sowas kurz und klar zu erwähnen.

    Jetzt mal ne Frage wegen den Klassen, wenn ich sie so wie im 2. Beispiel mache,
    und die Deklaration(?) in eine Headerdatei schreibe und die Definition der Funktionen
    dann in eine normale Quellcode-Datei.
    Wie sieht das dann mit den Include-Direktiven aus?

    Die Header-Datei schreibe ich wegen mehrfachen includes so, soviel weiß ich schon 🙂

    #ifndef SUPER_KLASSE_H
#define SUPER_KLASSE_H
class super_klasse {
 ...
};
#endif

    Aber wo muss ich diese jetzt überall inkludieren?
    Ich mache euch mal nen Beispiel, denke dann könnt ihr es leichter erklären:

    // Hauptprogramm
int main () {
  super_klasse sk_var;
  return 0;
}

    // Header von super_klasse
#ifndef SUPER_KLASSE_H
#define SUPER_KLASSE_H
class super_klasse {
  private:
    void foo ();
};
#endif

    // Definition der Funktionen aus super_klasse
super_klasse::foo () {
  int i = 1*1;
}
    0
  • K

    ganz einfach:

    // myClass.h
#ifndef MEINE_KLASSE
#define MEINE_KLASSE
class myClass 
{
    public:
        int m_blablubb;
        int machwas();
};
#endif

// myClass.cpp
#include <iostream>
#include "myClass.h"

int myClass::machwas()
{
    std::cout << "hab was gemacht" << std::endl;
    return 0;
}

// meinProggie.cpp
#include "myClass.h"

int main()
{
    myClass mc;
    mc.machwas();
    return 0;
}

    und das ganze einfach mit dem compiler deiner wahl kompilieren. (z.b. mit gcc: g++ -o meinProg meinProggie.cpp myClass.cpp)
    (bei borland &co musst du die .cpp glaub ich zum projekt mit dazumatschen)

    0
  • S

    Das heißt die .cpp oder die .lib (je nachdem) muss ich dazulinken.
    Dann hab ichs verstanden 🙂

    0
  • S

    Noch ne kurze Frage, wenn ich einer Funktion virtual bei der Deklaration
    voranstelle, dann können sämtliche Kind-Klassen, diese optional überschreiben,
    müssen das aber nicht, richtig?
    Konstruktoren müssen immer neu geschrieben werden für die Kindklassen und werden
    nicht vererbt, richtig?

    Edit:

    Was mir noch einfällt (wollt ich schon am Anfang mitfrage hatte es aber vergessen :D)

    Wenn ich z.B. eine Klasse habe welche eine Verbindung in das Internet aufbaut,
    und ich möchte, dass diese Klasse bzw. ein Objekt der Klasse welches eine
    Verbindung darstellt, Informationen über den Aktuellen Status,Ping,IP des Hosts,Port,...
    auf Anfrage zurrückgeben kann, wie kann ich das realisieren?
    Unter C würde ich einfach eine Struktur verwenden, welche all diese Infos enthält.
    Aber wie macht man das in einer oo-Sprache?

    0
  • S

    SirLant schrieb:

    Noch ne kurze Frage, wenn ich einer Funktion virtual bei der Deklaration
    voranstelle, dann können sämtliche Kind-Klassen, diese optional überschreiben,
    müssen das aber nicht, richtig?
    Konstruktoren müssen immer neu geschrieben werden für die Kindklassen und werden
    nicht vererbt, richtig?

    ja.
    ja.

    Unter C würde ich einfach eine Struktur verwenden, welche all diese Infos enthält.
    Aber wie macht man das in einer oo-Sprache?

    es spricht nichts gegen eine struktur.
    du kannst aber auch eine Klasse schreiben, die eben alle Verbindungsdaten beinhaltet und Zugriffsmethoden darauf anbietet.

    nimmt sich aber nicht viel...

    0
  • H

    in c++
    ist der einzige Unterschied zwischen einer Klasse und einer Struktur doch
    nur das Klasse automatsich private ist und bei einer Struktur halt public.

    Sonst gibts doch keinen Unterschied.

    0
  • ?

    HeikoKortlang schrieb:

    in c++
    ist der einzige Unterschied zwischen einer Klasse und einer Struktur doch
    nur das Klasse automatsich private ist und bei einer Struktur halt public.

    Sonst gibts doch keinen Unterschied.

    Das stimmt, aber die Rede war von C, wenn ich mich nicht irre:

    Unter C würde ich einfach eine Struktur verwenden, welche all diese Infos enthält.
    Aber wie macht man das in einer oo-Sprache?

    0
  • S

    Ich wüsste wie ich das in C am einfachste löse, mit nem neuen Datentyp.
    Hätte es in C++ wohl auch so gelöst, rein von der logik her, macht es ja auch
    Sinn 🙂

    Wollte nur sichergehen, dass ich mir nichts schlechtes angewöhne.

    0
  • B

    Korbinian schrieb:

    willst du immer noch eine funktion inline machen, so kennzeichnest du sie mit inline.

    Das reicht nicht. Eine inline-Funktion kannst du nur aufrufen, wenn ihre Definition sichtbar ist, d.h. sich in derselben Übersetzungseinheit befindet. Das heißt in der Praxis, dass die inline-Funktion im Header stehen muss (es sei denn sie wird nur in der Implementierungsdatei der Klasse benutzt.)

    SirLant schrieb:

    Aber wo muss ich diese jetzt überall inkludieren?

    Die Klassendefinition muss überall sichtbar sein, wo Interna der Klasse bekannt sein müssen. Das heißt z.b., wenn der Compiler die Größe braucht, wenn er den Konstruktor oder Destruktor aufrufen muss, wenn du Member benutzen willst sowieso etc. Eine einfache Deklaration der Klasse reicht aus, wenn:

    class Foo;
// ...
Foo f(); // als Rückgabetyp in einer Deklaration
void g(Foo); // als Parametertyp in einer Deklaration
Foo *p, *q;
Foo & r; // wenn sie in einer Deklaration als Pointer oder Referenz auftaucht
p = q; // Pointer können auch zugewiesen werden (es ist aber keine Pointerarithmetik möglich)
extern Foo e; // extern Deklaration
tmpl<Foo> t; // als Template-Argument

    Das ist wahrscheinlich keine erschöpfende Liste, aber alles was mir so einfällt.

    0
Anmelden zum Antworten