[C] Deklarationen und Definitionen erkennen
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 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.
int function(int a); // Dekl.
int function (int a) // Def. { ... } int i; // Sowohl Dekl. als auch Def. Wieso, kA. Mir stellen sich nun einige Fragen und zwar diese:
Code:
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 :mrgreen: )wissen.
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 Grüße |
Re: [C] Deklarationen und Definitionen erkennen
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:
hast, hast du ja einen Integer-Wert, der nun mal 4 Bytes belegt (32 Bit).
const int i = 4;
Chris |
Re: [C] Deklarationen und Definitionen erkennen
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:
Ist das, wie ich's vermutet hätte, eine Deklaration?
struct komplex {
double Realteil; double Imaginaerteil; };
Code:
Das hätte ich ebenfalls als Deklaration eingestuft, da es sich um Konstanten handelt. Was ist damit?
enum {A, B, C, D};
|
Re: [C] Deklarationen und Definitionen erkennen
"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 ;)
|
Re: [C] Deklarationen und Definitionen erkennen
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. ;) |
Re: [C] Deklarationen und Definitionen erkennen
Zitat:
Code:
übergeben kann.
void foo (const int& bar);
Wenn aber der Compiler feststellt, daß die Konstante nicht referenziert wird, kann er sie wegoptimieren (was in der Praxis meistens geschieht). Zitat:
Zitat:
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 (); } |
Re: [C] Deklarationen und Definitionen erkennen
Zitat:
Code:
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.
const int i = 5; // "sizeof i" liefert 4 Bytes
// mir wurde jedoch gesagt, Konstanten belegen keinen Speicher, was nun?
Code:
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.
enum {A, B, C, D}; // "sizeof A" liefert 4 Bytes, ist im Prinzip aber auch eine Konstante
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:
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.
struct komplex { // Ich hätte auf eine Dekl. getippt, aber "sizeof komplex" liefert 8 Bytes, wieso? o.O
double Realteil; double Imaginaerteil; };
Code:
Was ist denn das für ein Compiler, bei dem double nur 4 Byte breit ist?
struct komplex my_complex; // Def. mit 8 Bytes, wie ich's auch gedacht hätte
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 :mrgreen: |
Re: [C] Deklarationen und Definitionen erkennen
Code:
Das ist eine Variablendeklaration und keine Konstantendeklaration. C kennt namelich gar keine Konstanten. "const" bedeutet das man den Wert der Variablen nicht aendern kann.
const int i = 4;
Code:
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.
const char *a = "abcd";
char * const b = "efgh"; const char * const c = "ijkl" 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 = Variable ist in einem anderen File definiert. Dies ist die Deklaration.
extern const volatile unsigned int * const volatile clock = 0xEEDFADE;
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] |
Re: [C] Deklarationen und Definitionen erkennen
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. :gruebel: 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* |
Alle Zeitangaben in WEZ +1. Es ist jetzt 04:47 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz