[C++] Strukturen

L

Lukaz

Placebo-Effekt
13 April 2007
249
38
So wie sich mehrere Anweisungen zu Funktionen zusammenpacken lassen ist es auch möglich, mehrere Variablen zu einer Struktur zusammenzustellen. Diese Möglichkeit besteht jedoch in der Programmiersprache Javascript nicht, so dass folgendes Code-Beispiel der Programmiersprache C++ entnommen ist.
Code: 
struct adresse 
{ 
  string Vorname; 
  string Nachname; 
  string Strasse; 
  int PLZ; 
  string Ort; 
}; 

adresse MeineAdresse;
Durch das Erstellen einer Struktur ist es möglich, Datentypen in seinem Programm zu verwenden, die es noch nicht gibt. Nachdem C++ nicht von Haus aus einen Datentyp für die Speicherung von Adressen zur Verfügung stellt, können Sie dank Strukturen nun diesen Datentyp selber erstellen. Einmal erstellt können Sie wie gewohnt von diesem neuen Datentyp eine Variable anlegen. Im obigen Beispiel ist der Name der Variablen MeineAdresse. Und diese Variable kann nun Informationen vom Typ adresse speichern.
Zum Vergrößern anklicken....
Zitat Quelle
Also wie das ganze vom Prinzip her geht ist mir klar aber woher weis c++ was als was zählt? Denn in der Struktur muss c++ ja die übergebenen Adressen den Variabeln unterordnen oder? Wie funktioniert das ganze? Oder hab ich da was falsch verstanden?
 
Ein struct ist quasi eine Klasse wo jede Eigenschaft als public definiert ist also kannste z.B. so ne Adreese festlegen
Code: 
MeineAdresse.Vorname = "Udo";
MeineAdresse.Nachname = "Mustermann";
MeineAdresse.Straße = "Musterstraße 1";
MeineAdresse.PLZ = 12345;
MeineAdresse.Ort = "Musterstadt;
 
Lukaz,

Deine Frage wurde ja wohl noch nicht beantwortet. Dann will ich das mal tun.

Wenn ich Deine Frage recht verstanden habe, möchtest Du wissen, woher der Compiler weiß, welcher Wert nun welchen Member der Struktur repräsentiert.
Natürlich geht das über die Spreicheradressen.
Irgendwo im Speicher ist die Struktur abgelegt. Und in diesem Speicherbereich sind dann die einzelnen Member der Struktur der Reihe nach abgelegt.
Nimm folgendes Beispiel (in C, nicht in C++) an:
Code: 
struct date
{
    unsigned char day;
    unsigned char month;
    short year;
};

struct person
{
    char* first_name;
    char* last_name;
    struct_date birthday;
};

struct person billyboy;
Nehmen wir an, daß der Wert der Variablen billiboy (also der Inhalt der Struktur) ab adresse X abgelegt ist und daß ein pointer 4 Bytes lang ist.

Dann sieht das Speicherlayout folgendermaßen aus
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| X+0 | X+1 | X+2 | X+3 | X+4 | X+5 | X+6 | X+7 | X+8 | X+9 | X+10| X+11|
+-----------------------+-----------------------+-----+-----+-----------+
| Adresse (first_name_) | Adresse_ (last_name_) | day |month| year |
+-----------------------+-----------------------+-----+-----+-----------+

(ein paar "_" als füllzeichen eingebastelt...)
Im compilierten programm finden sich - wenn es gestrippt ist - keine Variablennamen mehr, sondern es wird nur noch mit Adressen gearbeitet.

Die Zeichenketten für den Vornamen und den Nachnamen liegen dann irgendwo anders im speicher. Die genaue Adresse ist ja in der Struktur in den Bytes 0-3 bzw. 4-7 gespeichert.

Ach ja, die Aussage, daß man in C++ statt Strukturen lieber Klassen verwenden sollte ist ja schön und gut. Aber manchmal muß man C-Strukturen verwenden. Zum Beispiel, wenn man Kernelfunktionen aufrufen will, die eine C-Schnittstelle haben.
 
Zuletzt bearbeitet:
Außerdem kann man mit etwas Programmiergeschick und Disziplin auch mit C modulare Strukturen emulieren. Ich arbeite z.B. gern mit typedef

typedef struct date
{
unsigned char day;
unsigned char month;
short year;
} Date;

Date d1;

etc.
 
Ich persönlich würde natürlich auch einen typedef verwenden. Aber ich wollte nicht zusätzlich verwirren. Da das Thema aber schon angesprochen wurde, sollte man es vielleicht beleuchten.

typedef wird benutzt um neue Namen für Datentypen zu definieren.
Coded man etwa
typedef int harry;
dann könnte man überall wo int steht auch harry hinschreiben, also z.B.
harry a = 5;

Allgemein gesprochen könnte man die Syntax also so erklären:
typedef <variablentyp> <neuer name>;

Gerade im Zusammenhang mit struct und union führt das aber leicht zu Verwirrung. Warum sieht man an folgenden Beispielen:

typdef struct {int re; int im;} complex_t;
typdef struct complex {int re; int im;} complex_t;

Im ersten Fall ist der Typ, der einen neuen Namen bekommt ein struct, der keinen Namen hat, ein anonymer struct also. Anonyme structs machen nur dann einen Sinn, wenn man direkt Variablen von diesem Strukturtypen anlegt oder eben mit typdef einen Namen dafür definiert, bei dem netterweise das "struct" weggelassen werden kann.
Im zweiten Fall hat der struct bereits einen Namen: "blubb". Das typedef sorgt dann lediglich für eine Abkürzung - statt "struct blubb" kann gleichwertig "blubb_t" verwendet werden.
struct complex c = {5, 6};
wäre also gleichwertig zu
complex_t c = {5, 6};
Die Farben sollen übrigens helfen zu verstehen was nun was ist.

Den Namen mit "_t" (für Typ) zu verwenden ist übrigens sehr hilfreich um Konfusion zwischen den Namen von Variablen und den Namen von Typen zu vermeiden. Kunde_t ist der Typ Variable, der Kundendaten speichern kann, Kunde wäre eine Instanz diesen Typs, also eine konkrete Variable.
 
Du musst dich einloggen oder registrieren, um hier zu antworten.
Zurück
Oben