3. Klassenkonstruktor und Prototype

Klassenkonstruktor und Prototype

  • K

    Hi,

    ich habe wieder eine Frage, diesmal konzeptionell.

    Ich habe jetzt wieder einiges zu Funktionen gelesen und wenn ich das recht verstanden habe, dann ist die Deklaration des Prototypes in der Funktion lokal vorhanden.
    Also ich habe z.B. eine Funktion

    double function(double value)
{
  return value * value;
}

    Ich hoffe, ich verwende die Bezeichnungen jetzt richtig. Also

    double function(double value)

    wird doch als Prototype bezeichnet. Ich bezeichne jetzt mal double value als Deklaration, denn die Variable steht ja innerhalb der Funktion zur Verfügung, sprich sie ist deklariert.

    In dem Augenblick wo die Funktion aufgerufen wird, findet für value eine Art Initialisierung statt, oder nicht? Denn wenn ich mir vorstelle

    double function(double value)
{
  return value * value;
}

double x = 2;

double y = function(x);

    dann findet in der Zeile double y = function(x) in der Funktion doch quasi statt double value = x, also value = 2.

    So, kommen wir endlich zum Klassenkonstruktor. Was mich daran intuitiv ein wenig verwundert, dass eine dort deklarierte Variable nur innerhalb des Konstruktors lokal zur Verfügung steht und nicht der ganzen Klasse! Es mag konsistent sein mit der Verwendung von dem obigen Beispiel der Funktion.

    Also wenn ich z.B. habe

    class klasse{//
public:
  klasse(double value);

    dann 'lebt' value nur wenn ich den Konstruktor aufrufe. D.h. wenn ich jetzt eine Klassenvariable initialsieren möchte, so muss ich das ein wenig umständlich machen:

    class klasse{//
public:
  klasse(double value){ m_value = value; }
  double m_value;

    Irgendwie finde ich das ein wenig seltsam.

    Also wenn ich eine Funktion aufrufe, dann kann ich die Deklaration in dem Prototyp in der Funktion verwenden.

    Wenn ich eine Klasse aufrufe, so kann ich die Deklaration im Konstruktor allerdings nicht in der Klasse verwenden, wenn ich nicht den Wert in einer Klassenvariable speichere.

    Als würde ich eine Klasse aufrufen, den Konstruktor starten und der ist dann wieder zu Ende, aber die Klasse (das Objekt?) lebt nach wie vor noch.

    Versteht ihr was ich meine?

    Gruß,
    Klaus.

    0
  • Mod

    Eine Klasse ist eben keine Funktion. Die Memberfunktionen (also insbesondere der Konstruktor) sind Funktionen und für die gelten die üblichen Regeln. Der wichtigste Unterschied zu freien ("normalen") Funktionen ist, dass sie sich ein paar Variablen über das aufrufende Objekt teilen. Denk dir eine Klasse als Syntaxzucker, um folgendes häufiges C-Konstrukt schöner schreiben zu können:

    struct Klasse
{
 int membervariable;
};

void Klassenkonstruktor(struct Klasse *thispointer, int m)
{
 thispointer->membervariable = m;
}

void Klassenmemberfunkion(struct Klasse *thispointer)
{
  // Du würdest ja auch nicht erwarten, dass es hier eine Variable m gibt.
  // Aber thispointer->membervariable kannst du nutzen.
}

int main()
{
 struct Klasse foo;
 Klassenkonstruktor(&foo, 5);
 Klassenmemberfunktion(&foo);
}

    Außerdem google mal dringend das Stichwort
    Google: Initialisierungsliste C++

    edit: Habe ich deine Frage richtig verstanden? Mir ist nicht ganz klar, was du mit den Prototypen wissen möchtest. Ich habe den Eindruck, du hast die Begrifflichkeit von Definition, Deklaration und Funktionssignatur nicht ganz verstanden.

    0
  • K

    SeppJ schrieb:

    edit: Habe ich deine Frage richtig verstanden? Mir ist nicht ganz klar, was du mit den Prototypen wissen möchtest. Ich habe den Eindruck, du hast die Begrifflichkeit von Definition, Deklaration und Funktionssignatur nicht ganz verstanden.

    Puh,
    was ist jetzt schon wieder Funktionssignatur? Ist das im englischen der Prototype?

    Also Deklaration ist für mich zunächst die Zuordnung eines Variablennamens an einen Typ, wie z.B.

    double variable;

    Die Funktionssignatur enthält eine Deklaration, nämlich welchen Typ die Funktion erwartet. Gleichzeitig sagt sie aus, was die Funktion zurückgibt, wie z.B.

    double function(int n);

    Also die Funktion function erwartet einen int Wert und gibt dafür einen double zurück.

    Die Definition sagt schließlich, was die Funktion mit dem int Wert macht:

    double function(int n)
{
  return n * n;
}

    EDIT:

    SeppJ schrieb:

    Denk dir eine Klasse als Syntaxzucker, um folgendes häufiges C-Konstrukt schöner schreiben zu können:

    struct Klasse
{
 int membervariable;
};

void Klassenkonstruktor(struct Klasse *thispointer, int m)
{
 thispointer->membervariable = m;
}

void Klassenmemberfunkion(struct Klasse *thispointer)
{
  // Du würdest ja auch nicht erwarten, dass es hier eine Variable m gibt.
  // Aber thispointer->membervariable kannst du nutzen.
}

int main()
{
 struct Klasse foo;
 Klassenkonstruktor(&foo, 5);
 Klassenmemberfunktion(&foo);
}

    Sorry, dass ich es scheinbar erst zu spät blicke? Ist das ein echter Arbeitsauftrag? Also soll ich eine Klasse basteln?

    Gruß,
    Klaus.

    0
  • ?

    Signatur == Name der Funktion + die Typen der Parameter. Was die Funktion zurück gibt ist nicht Teil der Signatur.
    Eine Deklaration macht den Namen der Funktion bekannt, insbesondere gehört dazu auch der return-Typ sowie Anzahl und Art der Parameter! Signatur und Deklaration sind also unterschiedliche Dinge.

    0
  • K

    arghonaut schrieb:

    Signatur == Name der Funktion + die Typen der Parameter. Was die Funktion zurück gibt ist nicht Teil der Signatur.
    Eine Deklaration macht den Namen der Funktion bekannt, insbesondere gehört dazu auch der return-Typ sowie Anzahl und Art der Parameter!

    Ui ui,
    also wenn ich in einer Zeile schreibe

    double function(double value);

    dann ist das erste double Deklaration und der ganze Rest Signatur?

    Junge Junge, das ist aber penibel.

    Gruß,
    Klaus.

    0
  • 3

    Gegeben sei eine Deklaration:

    double foo(int, bool, char);

    Signatur davon: (int, bool, char)
    Prototyp davon: double(int, bool, char)

    0
Anmelden zum Antworten