Definieren, Deklarieren, Initialisieren

777

Hey ihr,

Habe mir gedacht, dass es für Neulinge sicher wichtig ist, wenn einmal Klarheit über einige Begriffe gegeben wird, welche oft im Programmierergenrè fallen.

Definieren:

Bei der Definition einer Variable, wird dieser Speicherplatz zugewiesen, ihr Typ wird festgelegt und es kann ihr ein Anfangswert mitgegeben werden.
Bsp.:

int a = 5;

oder natürlich auch ohne Wert:

int a;

Deklarieren:

Bei der Deklaration muss einer Variable noch kein Speicherplatz zugewiesen werden, ihr Typ wird jedoch festgelegt.

Bsp.:

int a;

Eine Deklaration beinhaltet dann eine Definition, wenn eine Variable Speicherplatz zugewiesen, ihr Typ festgelegt und ihr Name festgelegt wird.

int a = 5;

oder auch:

int a;

Eine Deklaration beinhaltet dann KEINE Definition, wenn mit dem Schlüsselwort 'extern' explizit kein Speicher zugewiesen wird:

extern int a;

Folgender Quelltext würde also einen Fehler melden.
Denn keine Variable kann ohne Speicherplatz zu besitzen einen Wert zugewiesen bekommen.

#include <iostream>
int main(void)
{
   extern int a=5;   //VERBOTEN! 'a' hat noch keinen Speicherplatz.
}

Eine Deklaration OHNE Definition ist dann sinnvoll, falls mehrere Programmteile sich die Variable einer Headerdatei teilen müssen.
Das Schlüsselwort 'extern' wird man also meistens nur in Headerdateien finden.

Initialisieren:

Initialisieren bedeutet lediglich, dass der Wert einer Variable während ihrer definition direkt ein Anfangswert zugewiesen wird.

Bsp.:

int a = 5;    //Variable 'a' wird mit Wert 5 initialisiert.

oder...

int a(5)  //Variable 'a' wird auch mit 5 initialisiert.

Richtig so?

Hab mich gerade mal mit den Begrifflichkeiten auseinander gesetzt, weil man immer wieder drauf stößt und es besser ist, wenn man mal ganz genau weiß, was was ist.

cya
David

Badestrand

Also das mit deklarieren und definieren stimmt schonmal nicht so ganz :p Wieso wird denn hier int a; "Speicherplatz zugewiesen" und hier nicht int a;
Und int a; a=5; ist keine Initialisierung mehr, da Variablen nur bei der Deklaration initialisiert werden können

Und guck mal hier: http://www.c-plusplus.net/forum/viewtopic-var-t-is-61231.html :p

777

Bei der Deklaration muss einer Variable noch kein Speicherplatz zugewiesen werden, ihr Typ wird jedoch festgelegt.

'MUSS' noch kein Speicherplatz zugewiesen werden.
Danach kommt ja noch die Erklärung dazu.

HumeSikkins

Hallo,
lass uns bei dem von Badestrand zitierten Link bleiben.

Denn:

Eine Definition beinhaltet dann eine Deklaration, wenn eine Variable Speicherplatz zugewiesen, ihr Typ festgelegt und ihr Name festgelegt wird.

Käse. Eine Definition ist *immer* auch eine Deklaration.

Eine Definition beinhaltet dann KEINE Deklaration, wenn mit dem Schlüsselwort 'extern' explizit kein Speicher zugewiesen wird:

Käse. In diesem Fall ist es eine Deklaration und keine Definition.

Folgender Quelltext würde also einen Fehler melden.
Denn keine Variable kann ohne Speicherplatz zu besitzen einen Wert zugewiesen bekommen.
#include <iostream>
int main(void)
{
   extern int a=5;   //VERBOTEN! 'a' hat noch keinen Speicherplatz.
}

Käse. In diesem Fall wird aus der Deklaration schlicht eine Definition. Machst du das in einem Header, bekommst du Probleme, wenn dieser Header in mehreren ÜE eingebunden wird, da a dann mehrfach definiert wird.

Initialisieren:

Initialisieren bedeutet lediglich, dass der Wert einer Variable festgelegt oder verändert wird.

Bsp.:
int a;
a = 5;    //Variable 'a' wird mit Wert 5 initialisiert.
oder...
int a(5)  //Variable 'a' wird direkt mit 5 initialisiert.

Initialisieren geht immer Hand in Hand mit Definieren. D.h. int a = 5; ist eine Initialisierung. int a; a = 5; hingegen ist eine Definition gefolgt von einer Zuweisung.

777

mhh... dann hab ich da wohl was durcheinander geworfen^^
Hab jetzt oben noch was geändert...

Allerdings das initialisieren und zuweisen auch nochmal nen Unterschied ist, wusste ich noch nich

pumuckl

Um mal Zusammenszufassen was ich hier und aus anderen Quellen rausgelesen hab, soweit wie ich das verstehe:

Deklaration:

Variablen: werden durch Angabe des Typs und ihres Namens deklariert
Eine reine Deklaration kann bei freien Variablen (nicht-Membern) nur durch das Schluesselwort extern bewirkt werden, andernfalls geht die Deklaration immer mit der Definition einher
Klassen/structs: werden durch das Schluesselwort class/struct und den Namen deklariert, Beispiel:

class MyClass;

Funktionen: werden durch Angabe des Rueckgabewertes, des namens und der Parameterliste deklariert, sowie bei Memberfunktionen durch etwaige const- und volatile-Spezifizierer Beispiel:

void f(int);
string g(double d);

Definition:

Variablen: freie Variablen werden definiert, sobald ihnen vom Compiler Speicher reserviert wird. Dies geschieht bei jeder Deklaration ohne das Schluesselwort extern . Eine Definition von Variablen geht immer mit ihrer Initialisierung einher. Nichtstatische-membervariablen werden nur deklariert, aber nicht definiert, da ihre Speicherreservierung mit der Definition der zugehoerigen Objektvariablen implizit erfolgt. Statische Membervariablen muessen bei oder nach ihrer Deklaration definiert (und damit initialisiert) werden.
Klassen/structs: werden definiert durch Angabe des Schluesselwortes class/struct, gefolgt vom Namen und den in geschweiften Klammern eingefassten Deklarationen oder Definitionen von Membervariablen und Memberfunktionen (und Zugriffsbezeichnern), Beispiel:

class MyClass {
  int c; //deklaration
  static const double d = 3.45; //definition
  void foo() const; //deklaration
  int bar() { return 42; } //definition
};

Funktionen: werden definiert durch Angabe der Funktionssignatur (wie Deklaration) gefolgt vom Funktionsrumpf in geschweiften Klammern.

Initialisierung:
Ist die Belegung von Variablen/Objekten mit Anfangswerten. Sie erfolgt in C++ sobald der Speicherplatz bereitgestellt wurde. Membervariablen werden in der initialisierungsliste des Klassenkonstruktors initialisiert, freie Variablen werden durch Aufruf ihres Konstruktors (bei Klassenvariablen) bzw. Zuweisung eines Wertes (bei eingebauten Datentypen) initialisiert. Wird ein eingebauter Datentyp ohne expliziten Initialisierungswert definiert, so erfolgt die Initialisierung mit einem nicht naeher definierten Wert (z.B. dem was grade an der Stelle im Speicher steht). Beispiel:

struct D {  //definition eines struct
  D()            //definition des default-Ctors
     : i(5), f(4.3f) {}  //initialisierung der membervariablen
  D(D const& other);  //deklarationn des copy-ctors
  int i;    //deklaration der membervariablen    
  float f;
};

D::D(D const& other) //definition des copy-ctors
  : f(other.f)       //initialisierung der member
{
  i = other.i;       //ZUWEISUNG - da i in der initialisierungsliste nicht
}                    //auftaucht wurde es "zufaellig" initialisiert

int main()
{
   int myint = 9;  //Definition und Initialisierung mit 9
   int thyint;     //Definition und Initialisierung mit was auch immer
   D d1;           //Definition und Initilaisierung durch default-Ctor
   D d2(d1);       //Definition und Initialisierung durch copy-ctor
   D d3 = d2;      //Definition und Initialisierung durch copy-ctor
}

Bitte um Korrektur falls da was Kaese ist