C-Datentypen, Felder und Zeiger

Die Bitbreite der Datentypen kann auf unterschiedlichen Systemen variieren, deshalb gibt es alternative Bezeichnungen, aus denen die Bitbreite hervorgeht.

sizeof() gibt die Byte-Grösse einer Variablen zurück.

Variabeln werden entweder in Registern oder im SRAM gespeichert. Durch die vielen GPR (General Purpose Register) werden bei wenigen einfachen Variablen zuerst diese verwendet, bevor auf das SRAM ausgewichen wird.

Hinweis: Hier wird davon ausgegangen, dass die Variabeln im SRAM gespeichert werden.

Beim Definieren von Variablen wird vom Compiler Speicherplatz entsprechend des Datentyps reserviert.

Unter dem Namen (Identifier) merkt sich der Compiler die Startadresse der Variable. Der Speicher hat dabei zunächst zufällige, alte, undefinierte Werte. Durch Initalisierung können Startwerte vorgegeben werden.

char zeichen = 3;
int zahl = 0x1234;

Bei zahl wird Little Endian Speicherung verwendet:
Das niederwertigste Byte zuerst speichern.

char feld[] = {1,2,3};
// feld    hat den Wert 0x0063
// feld[0] hat den Wert 1

char text[5]="Bla";

Für das Textfeld werden 5 Byte reserviert. Initialisiert wird es mit einem String, der nur 4 Byte lang ist: Drei Zeichen und eine 0 als Terminalsymbol um das Ende zu markieren. Byte 5 bleibt somit undefiniert.

char feld2[2][3] = {{1,2,3},{4,5,6}};
// feld2       hat den Wert 0x006b
// feld2[1][0] hat den Wert 4

Indexberechnungen

Der Compiler ermittelt den Inhalt von Feld-Elementen mit Rechnungen wie diesen:

text[n] = inhalt_von(text + n*sizeof(text[0]))

feld2[a][b] = inhalt_von(feld2+ a*sizeof(feld2[0])+b*sizeof(feld2[0][0]))

 

Die inhalt_von-Funktion ist der *-Operator siehe Zeiger

Unter einem Zeiger (engl. Pointer) versteht man den Verweis, die Referenz auf eine Speicheradresse.

Ein Zeiger ist eine Variable, die sich eine Speicheradresse merken kann.

char *zeichen_ptr; // Zeiger auf char definieren
zeichen_ptr = &zeichen; // Adresse von zeichen zuweisen

*-Operator dereferenziert den Zeiger, greift auf Wert der referenzierten Speicheradresse zu.

&-Operator gibt die Adresse der Variablen zurück

// &zeichen    ergibt 0x0060
// zeichen_ptr ergibt 0x0060
// *zeichen_ptr ergibt 3
int zahlen[] = {1,2};
int *zahlen_ptr = &zahlen[1];

Der Speicher beginnt bei 0x0060. Ermitteln Sie den Speicherinhalt (Tabelle) und die Ausgaben (mit cout) bei folgendem Code.

unsigned int muriel = 0x0815;
int *sister_ptr = &muriel;
cout << *sister_ptr; // welchen Wert hat *sister_ptr
*sister_ptr = 0x6666;
cout << muriel;
unsigned char tom = 128;
char *tom_prt = &tom;
cout << *tom_ptr;
char biene[3][2] = {{1,2},{3,4}};
cout << sizeof(biene);
char *bee_ptr = &biene[2][0];
cout << bee_ptr;
*bee_ptr = 7;
*(++bee_ptr) = 8;
cout << bee_ptr;

Bei AVR-µC sind Daten- und Programmspeicher getrennt (Havard-Architektur) dies bereitet mit dem GCC einige Probleme, da dieser für die Von-Neumann-Architektur konstuiert wurde, bei dem von einem durchgehenden Speicherbereich ausgegangen wird. Bei zwei getrennten Speichern kommen Adressen doppelt vor, auch der Zugriff auf Daten im Flash funktioniert anders als beim SRAM. Mit PROGMEM können konstante Daten im Flash-Speicher untergebracht werden.
[mikrocontroller.net/articles/AVR-GCC-Tutorial] [<avr/pgmspace.h>: Program Space Utilities].

#include <avr/pgmspace.h>

const int zahl PROGMEM = 0x1234;
const char text[] PROGMEM = "Bo";

Gelesen werden die Daten mit besonderen Funktionen, denen die Speicheradresse der Daten mittels des &-Operators übergeben wird.

// pgm_read_word(&zahl) ergibt 0x1234
// pgm_read_byte(&text[1]) ergibt 'o'