[C] Deklarationen und Definitionen erkennen

[Matze]

Hi,

ich traue mich kaum diese Frage zu stellen, doch ich möchte nun Gewissheit und wende mich an euch, auch wenn es noch so trivial sein könnte.

Ich möchte wissen, wie ich eine Deklaration und eine Definition erkennen kann. Meines Wissens werden die Begriffe in Pascal genau umgekehrt verwendet als in C, doch in C gibt's da einige Dinge, die in Pascal so gar nicht gehen.

Fakt ist, eine Definition reserviert Speicher, eine Deklaration nicht (zumindest in C). Nur muss ich nun erkennen können, was Speicher reserviert und was nicht.

Das hier ist glaub immer so und daher kann ich das nun erkennen:

Code:

int function(int a);    // Dekl.

int function (int a)    // Def.
{
  ...
}

int i;                  // Sowohl Dekl. als auch Def. Wieso, kA.

int i außerhalb der main-Funktion wäre eine Definition und das entsprechende extern i die zugehörige Deklaration. Sowas geht in Delphi meines Wissens nicht. Aber das ist auch nicht mein Problem, ich hab's nur ergänzend erwähnt.

Mir stellen sich nun einige Fragen und zwar diese:

Code:

const int i = 5;        // "sizeof i" liefert 4 Bytes
                        // mir wurde jedoch gesagt, Konstanten belegen keinen Speicher, was nun?

enum {A, B, C, D};      // "sizeof A" liefert 4 Bytes, ist im Prinzip aber auch eine Konstante

struct komplex {        // Ich hätte auf eine Dekl. getippt, aber "sizeof komplex" liefert 8 Bytes, wieso? o.O
  double Realteil;
  double Imaginaerteil;
};

struct komplex my_complex;   // Def. mit 8 Bytes, wie ich's auch gedacht hätte

Könnt ihr mir bitte verständlich erklären, wie ich sicher erkennen kann (ohne Compiler, sondern aus dem Kopf), was eine Definition und was eine Deklaration ist? Diese Begriffe werden sehr oft verwechselt, was normalerweise auch nicht schlimm ist, nur muss ich das (bis einschließlich Dienstag, danach nicht mehr )wissen.

Grüße

[CalganX]

Hi,
ich bin mir nicht hundertprozentig sicher, aber sizeof gibt dir nicht die Größe des tatsächlich belegten Speichers an, sondern die Größe der Information allgemein. Und wenn du

Code:

const int i = 4;

hast, hast du ja einen Integer-Wert, der nun mal 4 Bytes belegt (32 Bit).

Chris

[Matze]

Hi danke,

dass ein Integer 4 Bytes groß ist, ist mir klar. Nur dachte ich, Konstanten belegen keinen Speicher und das kann ich mit sizeof prüfen. Dann ist dem wohl nicht so.

Belegt eine mit const de[klar/fin]ierte Variable nun Speicher oder nicht?
Und wie ist das beim Struct:

Code:

struct komplex {
  double Realteil;
  double Imaginaerteil;
};

Ist das, wie ich's vermutet hätte, eine Deklaration?

Code:

enum {A, B, C, D};

Das hätte ich ebenfalls als Deklaration eingestuft, da es sich um Konstanten handelt. Was ist damit?

[Dax]

"Const" ist eine witzige Sache, weil (so wie ich es verstehe) const-Werte viel mit Makros gemeinsam haben. Statt sizeof(i) stieht der Compiler also sizeof(4) - und damit kommt auch 4 raus. Ebenso operiert sizeof() nicht nur auf konkrete Objekte, sondern auch auf Typen, siehe sizeof(string) in Delphi

[Matze]

Ok, dann vergessen wir ganz schnell, dass ich versucht habe, mit sizeof (das ist in C übrigens keine Funktion!) den reservierten Speicher ermitteln kann.
Meine Probleme bestehen aber weiterhin.

[DMW]

Zitat von Matze:

Mir stellen sich nun einige Fragen und zwar diese:

Code:

const int i = 5;        // "sizeof i" liefert 4 Bytes
                        // mir wurde jedoch gesagt, Konstanten belegen keinen Speicher, was nun?

Konstanten belegen durchaus Speicher. Sie müssen im Speicher existieren und eine Adresse haben, da man sie z.B. an Funktionen wie

Code:

void foo (const int& bar);

übergeben kann.
Wenn aber der Compiler feststellt, daß die Konstante nicht referenziert wird, kann er sie wegoptimieren (was in der Praxis meistens geschieht).

Zitat von Matze:

Code:

enum {A, B, C, D};      // "sizeof A" liefert 4 Bytes, ist im Prinzip aber auch eine Konstante

Das gleiche gilt hier.

Zitat von Matze:

Code:

struct komplex {        // Ich hätte auf eine Dekl. getippt, aber "sizeof komplex" liefert 8 Bytes, wieso? o.O
  double Realteil;
  double Imaginaerteil;
};

In der Tat seltsam - eigentlich sollten es 16 Bytes sein
komplex ist eine Struktur, und mit sizeof(komplex) erfährst du, wieviel Bytes eine Instanz dieser Struktur benötigt. sizeof(instanz_von_komplex) liefert das gleiche Ergebnis.


Zur allgemeinen Vermeidung der Verwechslung von Deklaration und Definition mag es sinnvoll sein, "Implementation" statt "Definition" zu benutzen.
Ansonsten gilt:
- eine Deklaration "deklariert" ein Objekt oder eine Funktion, macht es bekannt.
- eine Definition "beschreibt" bzw. "implementiert" ein Objekt oder eine Funktion.

Aus Sicht des Compilers:
- eine Deklaration gibt die Information an, die der Compiler für den Umgang mit dem Objekt oder der Funktion benötigt (für Objekte: Datentyp, Größe, Methoden; für Funktionen: Rückgabetyp, Parameterzahl, Parametertypen).
- eine Vorwärtsdeklaration eines Typs macht nur seinen Namen verfügbar. Da seine Größe nicht bekannt ist, kann er nicht instantiiert werden; es können lediglich Zeiger und Referenzen auf ihn benutzt werden.
- eine Definition implementiert die durch die Deklaration beschriebene Funktionalität. Sie ist für den Compiler für Aufrufe der Funktion oder Instantiierungen des Typs nicht vonnöten, erst der Linker führt Implementation und Referenzen zusammen. (Ausnahme sind hier Templates; da hier die Typinformation bei der Deklaration nicht vollständig ist (man kann jeden beliebigen Typ als Templateparameter einsetzen, auch Typen, die erst später deklariert werden), ist es nicht möglich, eine spezialisierte Implementation bereitzustellen; die generische Implementation muß dem Compiler folglich zur Verfügung stehen, da er sie zur Spezialisierung benötigt.)

Code:

extern int i; // Deklaration
int i; // Definition

extern void foo (void); // Deklaration; extern ist hier optional und wird per Default angenommen
void foo (void) {} // Definition bzw. Implementation

class myClass; // Vorwärtsdeklaration
class myClass // Deklaration
{
public:
   void bar (void);
};
void myClass::bar (void) // Definition bzw. Implementation
{
  foo ();
}

[Olli]

Zitat von Matze:

int i außerhalb der main-Funktion wäre eine Definition und das entsprechende extern i die zugehörige Deklaration. Sowas geht in Delphi meines Wissens nicht. Aber das ist auch nicht mein Problem, ich hab's nur ergänzend erwähnt.

extern könnte man eher mit einem forward (in Delphi nur für Funktionen und nur in der gleichen Datei - abgesehen von Includes! - gültig) vergleichen. Da in Delphi keine sichtbare Trennung von Compiler und Linker existiert, kann es das in Delphi so auch nicht geben, denn extern besagt ja, daß da irgendwo ein Symbol dieses Namens existiert, was zur Linkzeit dann zur Verfügung stehen wird.

Code:

const int i = 5;        // "sizeof i" liefert 4 Bytes
                        // mir wurde jedoch gesagt, Konstanten belegen keinen Speicher, was nun?

Wer hat das gesagt? Der sizeof-Operator sieht, daß es eine "Variable"/Konstante des Typs int ist und stellt damit nur fest, daß die Größe dann 4 ist. Abgesehen davon belegen Konstanten natürlich auch Speicher, nämlich in der EXE- Das ist aber compilerabhängig und damit eine andere Diskussion.

Code:

enum {A, B, C, D};      // "sizeof A" liefert 4 Bytes, ist im Prinzip aber auch eine Konstante

Was die Voreinstellung ist, da Aufzählungen kompatibel zu Integers sind. Übrigens läßt sich (wie in Delphi auch) die Bittigkeit der Aufzählungstypen auch in C/C++ festlegen.

Stell dir sizeof als Operator vor der nur auf Typen angewendet werden kann. Sobald dort eine Variable oder Konstante (also eine "Instanz" eines Typs) steht, wird implizit die Größe des Typen der "Instanz" ermittelt (s.o.).

Code:

struct komplex {        // Ich hätte auf eine Dekl. getippt, aber "sizeof komplex" liefert 8 Bytes, wieso? o.O
  double Realteil;
  double Imaginaerteil;
};

Bei einem double würde ich 16 Byte gesamt erwarten, aber in jedem Fall haben wir es hier mit soetwas wie einem Typen (wenn auch nicht einem echten typedef) zu tun. Das wäre übrigens etwas wo ich stolpern würde, weil ich das intuitiv als "lokalen Typ" ansehe und somit in der Tat als Deklaration. Als typedef würde es dann zu einem "globalen Typ" geadelt.

Code:

struct komplex my_complex;   // Def. mit 8 Bytes, wie ich's auch gedacht hätte

Was ist denn das für ein Compiler, bei dem double nur 4 Byte breit ist?

Bei Funktionen ist es ganz einfach. Ohne Rumpf ist es eine Deklaration, mit Rumpf eine Definition. Beim Rest ist das alles sehr schwammig, wenn es also für eine Vorlesung ist, am besten an das vorgegebene Material halten. Genau wie Fahrschule

[Robert Marquardt]

Code:

const int i = 4;

Das ist eine Variablendeklaration und keine Konstantendeklaration. C kennt namelich gar keine Konstanten. "const" bedeutet das man den Wert der Variablen nicht aendern kann.

Code:

const char *a = "abcd";
char * const b = "efgh";
const char * const c = "ijkl"

Alles drei sind Variablendeklarationen. Bei a ist der Zeiger konstant, daher kann man den Zeiger nicht umsetzen. Die Daten auf die der Zeiger zeigt kann man hingegen veraendern. Bei b ist es umgekehrt. der Zeiger laesst sich veraendern, aber die Daten auf die er zeigt nicht. Bei c geht keines von beiden.

Es gibt in C noch das gegensaetzliche Keyword volatile. Es besagt das die Variable sich ausserhalb des Einflussbereiches des Programms aendern kann. Der Compiler darf daher keine Optimierungen vornehmen.
Dies fuehrt zum Prunkstueck der C-Deklarationen:

Code:

extern const volatile unsigned int * const volatile clock = 0xEEDFADE;

extern = Variable ist in einem anderen File definiert. Dies ist die Deklaration.
const = man kann den Zeiger nicht aendern.
volatile = der Zeiger aendert sich von alleine (unwahrscheinlich das es so etwas gibt, aber warum nicht).
unsigned int = Cardinal.
const = man kann die Uhr nicht stellen.
volatile = die Uhrzeit aendrt sich von alleine.
0xEEDFADE = irgendwohin muss der Zeiger zeigen. Hier nur eine Beispielinitialisierung.

[edit=Matze][c]-Tag repariert. MfG, Matze[/edit]

[Matze]

Hi,

vielen Dank für eure Antworten.

Ich habe das Projekt nochmals neu erstellen lassen und nun sind es die erwarteten 8 Byte für double. Komisch oder ich hab gestern irgendwelchen Mist gebaut, was wohl wahrscheinlicher ist.

Ich werde mir eure Beispiele von euch nachher in Ruher durch den Kopf gehen lassen und versuchen, das genau zu verstehen, wobei ich befürchte, dass es nicht so leicht ist. C kann ganz schön kompliziert sein, habe ich gemerkt. *g*