Mit C anfangen > Header und Source

[Raildex]

Hi Leute!

Ich hab mir mal überlegt mit C anzufangen und so.
Hab da auch gleich mal eine Frage.
Ich verstehe den Verwendungszweck von Header und Source-Dateien nicht so ganz.
Also Header-Dateien haben ja nur Deklarationen von Datentypen und Funktionsköpfe.

Ich habe bisher immer nur mit Java gearbeitet, ich würde also jetzt einfach mal so sagen, dass eine Header Datei eine Art Interface wie in Java ist.

Die Source Datei hingegen hat dann die eigentliche Implementierung der Funktionen und Variablen.
Wieso trennt man das? Wieso packt man das denn nicht einfach in eine Datei und gut ist?
Ich mein, wenn ich ne Source Datei schreibe, brauche ich doch sowieso den Header dazu.

Ich hab mir ein Buch zur Spieleprogrammierung mit dem Gameboy geholt, weil ich Gameboy sowieso mag :>
Und hab mich mal an einer Header-Datei versucht.

#ifndef CHARACTERS_H
#define CHARACTERS_H
extern struct party
{
unsigned char partySize;
struct character[] characters;
}
extern struct character
{
char name[8];
unsigned char level;
unsigned short hp,hp_max,mp,mp_max,exp,expNext;
unsigned char str,def,agi,spr,rfx,hit;
}


void addToParty(struct character);
void deleteFromParty(struct character);
#endif
Ist das so richtig? Das Buch erklärt leider nur die Grundlagen wie schleifen etc, was ich ja bereits kenne.

[Whiz-zarD]

Der Grund ist, dass C die Funktionen sequentiell abläuft. Beispiel: Stell dir vor, du hast zwei Funktionen:



void a()
{
b();
}

void b()
{
// tu was
}


In der Funktion a() wird b() aufgerufen. Der Compiler weiß aber noch nichts von b(), da diese Funktion erst nach a() definiert wird. Folglich hat er auch noch keine Sprungmarke.
Mit der Header-Datei lässt sich dieses Problem nun beheben. Die Header-Datei reserviert nun für jede Funktion Sprungmarken, sodass nun a() weiß, wohin es springen muss, wenn b() aufgerufen wird.

Dieses Verhalten kannst du auch nachvollziehen, da die Funktionen nicht unbedingt in der Header-Datei stehen müssen. Du kannst mein Beispiel übernehmen. Erst wenn du b() zuerst definierst, kann a() auch b() aufrufen.
Also anstatt den oberen Code musst du dann:



void b()
{
// tu was
}

void a()
{
b();
}


schreiben.

Bei aktuellen Sprachen ist die Header-Datei nicht mehr nötig, weil der Code zuerst analysiert wird, und dann für jede Methode/Funktion implizit schon eine Sprungmarke definiert wird. Aktuelle Compiler bauen also quasi implizit die Header-Datei selbst.

[Raildex]

Alles klar! Vielen Dank für die Auskunft :]

[Raildex]

Sorry für Doppelpost!

Ich hätte da eine Frage.

Der lcc -Compiler, den ich verwende, kann wohl Designated Initializers nicht.

sowas wie
monsterDatabase[0].name = "Dive Bird"; monsterDatabase[0].hp = 35;
monsterDatabase[0].mp = 6;
monsterDatabase[0].level = 1;
monsterDatabase[0].str = 3;
monsterDatabase[0].def = 4;
monsterDatabase[0].agi = 4;
monsterDatabase[0].spr = 7;
monsterDatabase[0].rfx = 4;
monsterDatabase[0].hit = 7;
funktioniert also nicht. Gibt es eine andere Möglichkeit?

monsterDatabase[0] = {"Jelly Blob",35,6,2,2,1,3,4,4,7,4,7};
scheint er auch nicht zu mögen ._."

[Whiz-zarD]

Wie lautet denn die Fehlermeldung? Wie sieht der restliche Code aus? Wie hast du denn das Array definiert?
Ich hoffe, dir ist auch klar, dass du bei C selbst für die Speicherverwaltung zuständig bist.

[Raildex]

Ah, hab herausgefunden wie ich das ganze initialisiere:

typedef struct monster
{
char name[12];
unsigned short hp,mp,exp,money;
unsigned char level,str,def,agi,spr,rfx,hit;
unsigned char skills[4];
}Monster;
const Monster monsterDatabase[5] =
{
{"Jelly Blob",20,10,2,2,1,3,4,4,7,4,7,{0,0,0,3}},
{"Dive Bird",35,6,2,2,1,3,4,4,7,4,7,{0,0,0,0}}
};

Hätte man auch sofort draufkommen können.

[Raildex]

Hi, ich bins nochmal.

Ich versuch gerade, Bit Felder aufzubauen.
Mein Struct dazu sieht so aus:


typedef struct flags
{
unsigned char MAP_CONTROL:1;
unsigned int MAP_BATTLE:1;
unsigned int SCN_TRANS:2;
unsigned int STATE:3;
}FLAGS;
FLAGS flags =
{
0,0,0,0
};


Kann ich die Member des Structs ganz normal mit anderen Zahlen vergleichen, also
beispielsweise

if(flags.STATE == 1)?

Der SDCC Compiler, den ich verwende, scheint damit jedenfalls Probleme zu haben, weil er nen fatal error ausgibt.

[Whiz-zarD]

Warum nimmst du überhaupt den SDCC-Compiler? Dieser wurde für die Intel MCS-51-Familie optimiert.
Was soll diese Doppelpunkt-Angabe bei der Struct-Definition? Die ist mir nicht geläufig und ich finde auch darüber überhaupt nichts.

Und ja, du kannst die Werte des Structs ganz einfach mit Ganzzahlen vergleichen.

[Raildex]

Warum nimmst du überhaupt den SDCC-Compiler? Dieser wurde für die Intel MCS-51-Familie optimiert.
Ich nutze eine andere Plattform und muss diesen Compiler nutzen, weils keinen anderen gibt.


Was soll diese Doppelpunkt-Angabe bei der Struct-Definition? Die ist mir nicht geläufig und ich finde auch darüber überhaupt nichts.
Wie ich schrieb, ist das Struct ein Bitfeld. Die Zahl hinter dem Doppelpunkt gibt an, wieviele Bits die Variable nutzt.
(Ich versuch so viel Platz zu sparen wie möglich. irgendwelche Flags würden immer ein ganzes Byte fressen. So kann ich mehrere Flags in ein Byte packen.)


Und ja, du kannst die Werte des Structs ganz einfach mit Ganzzahlen vergleichen.
Das ist ja das Problem, meine Dokumentation für den Compiler gibt keine Informationen darüber preis. Ich kriege halt einen Fatal Error.

Game.c(32):error *** FATAL Compiler Internal Error in file 'gen.c' line number '3758' : code generator internal error
Ich bin mir aber sicher, dass der gesamte Block

if(flags.STATE == 1) {
[...]
}else if(flags.STATE == 2)
{
[...]
}else if(flags.STATE == 3)
{
[...]
}else if(flags.STATE == 4)
{
[...]
}
gemeint ist.

[Raildex]

Hallöle, ich bins nochmal.

Dieses Mal geht es um Pointer.

Folgendes Setup:


typedef struct c {
UBYTE id;
UBYTE type;
}C;
typedef struct t
{
const UBYTE *array;
const C *arrayc;
}T;






const UBYTE main[] =
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xFF,0xFF,0xC0,0x80,0xBF,0x80,0xBF,0x80,
0xBF,0x80,0xBF,0x80,0xA0,0xDF,0xFF,0xFF,
0xFF,0xFF,0xF1,0x03,0x0D,0x01,0xFD,0x01,
0xF5,0x09,0xFD,0x01,0x8D,0x73,0xFF,0xFF,
0xFF,0xFF,0xF1,0x03,0x0D,0x01,0xFD,0x01,
0xF5,0x09,0xFD,0x01,0x3D,0xC3,0xFF,0xFF,
0xFF,0xFF,0x80,0xC0,0xBF,0x80,0xBF,0x80,
0xAF,0x90,0xBF,0x80,0xB0,0xCF,0xFF,0xFF,
0xFF,0xFF,0xC1,0xFF,0x90,0xFF,0x80,0xFF,
0x82,0xFF,0x80,0xFF,0xC0,0xFF,0xFF,0xFF,
0xFF,0xFF,0x03,0xFF,0x01,0xFF,0x01,0xFF,
0x21,0xFF,0x01,0xFF,0x03,0xFF,0xFF,0xFF,
0xFF,0xFF,0x83,0xFF,0x01,0xFF,0x05,0xFF,
0x01,0xFF,0x11,0xFF,0x03,0xFF,0xFF,0xFF,
0xFF,0xFF,0xC0,0xFF,0x80,0xFF,0x88,0xFF,
0x80,0xFF,0x80,0xFF,0xC0,0xFF,0xFF,0xFF,
0xFF,0xFF,0x02,0xFF,0x7F,0xFF,0x7F,0xFF,
0xFF,0xFF,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0x86,0xFF,0xFE,0xFF,0xFE,0xFF,
0xFE,0xFF,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0x2F,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xCB,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0x86,0xFF,0xFE,0xFF,0xFE,0xFF,
0xFF,0xFF,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xCB,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0x01,0x01,0x38,0x00,0xFF,0x00,
0xFF,0xFF,0xC4,0x3B,0x00,0xFF,0xFF,0xFF,
0x91,0x7E,0x10,0xFF,0xFF,0xFF,0xF8,0x07,
0x00,0xFF,0xFF,0xFF,0x93,0x7C,0x10,0xFF,
0xFF,0xFF,0xC0,0xC0,0x14,0x00,0xFF,0x00,
0xFF,0xFF,0x96,0xE9,0x80,0xFF,0xFF,0xFF,
0xE5,0x1E,0x04,0xFF,0xFF,0xFF,0x9C,0xE3,
0x80,0xFF,0xFF,0xFF,0x86,0x7D,0x04,0xFF,
0xFF,0xFF,0x01,0x01,0x38,0x00,0xFF,0x00,
0xFF,0xFF,0xC4,0x3B,0x00,0xFF,0xFF,0xFF,
0x91,0x7E,0x10,0xFF,0xFF,0xFF,0xF8,0x07,
0x00,0xFF,0xFF,0xFF,0x93,0x7C,0x10,0xFF,
0xFF,0xFF,0xC1,0xC1,0x15,0x01,0xFF,0x01,
0xFF,0xFF,0x97,0xE9,0x81,0xFF,0xFF,0xFF,
0xE4,0x1C,0x04,0xFC,0xFF,0xFF,0x9D,0xE3,
0x81,0xFF,0xFF,0xFF,0x84,0x7C,0x04,0xFC,
0xFF,0xFF,0x81,0x81,0xB8,0x80,0xFF,0x80,
0xFF,0xFF,0xC4,0xBB,0x80,0xFF,0xFF,0xFF,
0x11,0x1E,0x10,0x1F,0xFF,0xFF,0xF8,0x87,
0x80,0xFF,0xFF,0xFF,0x13,0x1C,0x10,0x1F,
0xFF,0xFF,0xC0,0xC0,0x14,0x00,0xFF,0x00,
0xFF,0xFF,0x96,0xE9,0x80,0xFF,0xFF,0xFF,
0xE5,0x1E,0x04,0xFF,0xFF,0xFF,0x9C,0xE3,
0x80,0xFF,0xFF,0xFF,0x86,0x7D,0x04,0xFF,
0x5E,0x01,0x0C,0x03,0x2C,0x03,0x1C,0x03,
0x2E,0x01,0x2A,0x05,0x1A,0x05,0x5C,0x03,
0x4E,0x01,0x0E,0x01,0x5A,0x05,0x0A,0x05,
0x28,0x07,0x2C,0x03,0x1E,0x01,0x5E,0x01,
0x7A,0x80,0x30,0xC0,0x34,0xC0,0x38,0xC0,
0x74,0x80,0x54,0xA0,0x58,0xA0,0x3A,0xC0,
0x72,0x80,0x70,0x80,0x5A,0xA0,0x50,0xA0,
0x14,0xE0,0x34,0xC0,0x78,0x80,0x7A,0x80,
0x70,0x80,0x54,0xA0,0x5C,0xA0,0x18,0xE0,
0x10,0xE0,0x31,0xC0,0x35,0xC0,0x75,0x80,
0x54,0xA0,0x5C,0xA0,0x58,0xA0,0x18,0xE0,
0x10,0xE0,0x34,0xC0,0x3D,0xC0,0x78,0x80,
0x0E,0x01,0x8A,0x05,0xA8,0x07,0x3C,0x03,
0x1C,0x03,0x0C,0x03,0x2E,0x01,0x3E,0x01,
0xBA,0x05,0x9A,0x05,0x8A,0x05,0xA8,0x07,
0x2C,0x03,0x3C,0x03,0x3C,0x03,0x9E,0x01,
0x00,0x00,0x00,0x00,0x1D,0x00,0x33,0x08,
0x73,0x08,0x6E,0x11,0xEE,0x11,0xEE,0x11,
0x00,0x00,0x40,0x20,0xC0,0x00,0x8C,0x42,
0x18,0x84,0x36,0x89,0xF5,0x0A,0xEA,0x14,
0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,
0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,
0xFA,0x05,0xF2,0x0D,0xF4,0x0A,0xE4,0x1A,
0x88,0x74,0x30,0xC8,0xC0,0x30,0x00,0xC0,
0x7F,0x80,0x7F,0x80,0x3F,0x40,0x3F,0x40,
0x1F,0x20,0x0F,0x10,0x03,0x0C,0x00,0x03,
0x00,0x03,0x03,0x0C,0x0F,0x10,0x13,0x20,
0x23,0x40,0x27,0x40,0x7F,0x80,0x7F,0x80,
0x00,0xC0,0xC0,0x30,0xF0,0x08,0xF8,0x04,
0xFC,0x02,0xFC,0x02,0xFE,0x01,0xFE,0x01,
0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,
0x00,0xFF,0x00,0xFF,0x00,0xFF,0x00,0xFF,
0xFA,0x05,0xF2,0x0D,0xF4,0x0B,0xE4,0x1B,
0x88,0x77,0x30,0xCF,0xC0,0x3F,0x00,0xFF,
0x7F,0x80,0x7F,0x80,0x3F,0xC0,0x3F,0xC0,
0x1F,0xE0,0x0F,0xF0,0x03,0xFC,0x00,0xFF,
0x00,0xFF,0x00,0xFF,0x04,0xFA,0x04,0xFA,
0x08,0xF4,0x30,0xC8,0xC0,0x30,0x00,0xC0,
0x00,0xFF,0x00,0xFF,0x00,0x7F,0x00,0x7F,
0x00,0x3F,0x00,0x1F,0x00,0x0F,0x00,0x03,
0x00,0xFF,0x04,0xFB,0x19,0xE6,0x33,0xCC,
0x6F,0x90,0x5F,0xA0,0xDE,0x21,0xBD,0x42,
0x00,0x00,0x04,0x00,0x19,0x00,0x33,0x08,
0x6F,0x10,0x5F,0x20,0xDE,0x21,0xBD,0x42,
0xBD,0x42,0xB9,0x46,0xBB,0x44,0xBB,0x44,
0xBB,0x44,0xBB,0x44,0x7B,0x84,0xFF,0x00,
0x22,0x00,0xCC,0x00,0x98,0x44,0xF0,0x08,
0x51,0xA8,0x6A,0x91,0xE5,0x12,0xED,0x12,
0xEB,0x14,0xE3,0x1C,0xDB,0x24,0xDF,0x20,
0xDF,0x20,0xFF,0x00,0xFF,0x00,0xFF,0x00,
0x22,0xDD,0xCC,0x33,0x98,0x67,0xF0,0x0F,
0x51,0xAE,0x6A,0x95,0xE5,0x1A,0xED,0x12,
0x00,0xFF,0x00,0x00,0xFF,0x00,0x39,0xC6,
0xD4,0xEF,0x02,0xFF,0x29,0xDF,0x10,0xFF,
0x82,0x7D,0x80,0x7F,0x22,0xDD,0xFF,0x00,
0xDF,0x20,0xFF,0x00,0x7E,0x81,0x1C,0xE3,
0x00,0xFF,0x00,0x00,0xFF,0x00,0xA7,0x58,
0x56,0xF9,0x89,0xFF,0x24,0xFF,0x02,0xFF,
0x00,0xFF,0x24,0xDB,0x6E,0x91,0xFF,0x00,
0xFF,0x00,0xFF,0x00,0x7C,0x83,0x54,0xAB,
0x00,0xF8,0x00,0x06,0xFC,0x01,0xA6,0x59,
0x56,0xF9,0x89,0xFF,0x25,0xFF,0x03,0xFF,
0x01,0xFF,0x59,0xA7,0x3F,0xC1,0xEF,0x11,
0xFF,0x01,0xFF,0x01,0xDD,0x23,0x09,0xF7,
0x00,0x7F,0x00,0x80,0x7F,0x80,0xB9,0xC6,
0xD4,0xEF,0x82,0xFF,0xA9,0xDF,0x90,0xFF,
0x82,0xFD,0x80,0xFF,0xA2,0xDD,0xFF,0x80,
0xDF,0xA0,0xFF,0x80,0xFE,0x81,0x9C,0xE3,
0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0xC6,
0x00,0xEF,0xC4,0x3B,0xE6,0x19,0xEF,0x10,
0x7D,0x00,0x7F,0x00,0xDD,0x00,0x00,0x00,
0x20,0x00,0x00,0x00,0x81,0x00,0xE3,0x00,
0x00,0xFF,0x00,0x00,0xFF,0x00,0xA7,0x58,
0x06,0xF9,0x50,0xAF,0xD9,0x26,0xFD,0x02,
0xFF,0x00,0xDB,0x00,0x91,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x83,0x00,0xAB,0x00,
0x00,0xF8,0x00,0x06,0xFC,0x01,0xA6,0x59,
0x06,0xF9,0x50,0xAF,0xD8,0x27,0xFC,0x03,
0xFE,0x01,0xA6,0x01,0xC0,0x01,0x10,0x01,
0x00,0x01,0x00,0x01,0x22,0x01,0xF6,0x01,
0x00,0x7F,0x00,0x80,0x7F,0x80,0x39,0xC6,
0x10,0xEF,0x64,0x9B,0x46,0x99,0x6F,0x90,
0x7D,0x80,0x7F,0x80,0x5D,0x80,0x00,0x80,
0x20,0x80,0x00,0x80,0x01,0x80,0x63,0x80,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};


const C coll[]=
{
{1,1},
{2,1},
{3,1},
{4,1},
{17,1},
{18,1},
{19,1},
{20,1},
{21,1},
{22,1},
{23,1},
{24,1},
{25,1},
{26,1},
{27,1},
{28,1},
{55,1},
{56,1},
{57,1},
{58,1},
{59,1},
{60,1},
{61,1},
{62,1},
{63,55},
{65,55},
{67,55},
{69,55}
};


const T g =
{
(const UBYTE *)main,
(const C *)coll
};

meine Frage ist nun: Da Coll und main beides Arrays sind, wie greife ich auf die einzelnen Elemente zu (Es sind ja Pointer zu Arrays)?

[dasDull]

Wenn man einen Array in einen Pointer castet, erhält man einen Zeiger auf die erste Zelle des Arrays (nicht auf "den ganzen Array").
(const UBYTE *)main ist also ein Pointer auf eine Speicherstelle der Größe einer UBYTE-Variable, nämlich auf den ersten Wert im Array.
Dieser Pointer ist in deiner Struktur als g.array verfügbar, und *(g.array) wäre der Wert in der ersten Arrayzelle.
Auf Zelle i lässt sich mit *(g.array + i) oder g.array[i] zugreifen. Letzteres ist nur eine andere Schreibweise für Ersteres.
Arrays und Pointer sind in C (fast) das Gleiche, der einzige Unterscheid ist im Prinzip, dass du mit einem Array nicht umspringen darfst, wie mit einer Variable (also z.B. wäre es sinnlos, einen Array zu inkrementieren).

[Raildex]

das hab ich mir schon gedacht,
allerdings zeigt


g.array[i]

immer 0 an. Egal, was für einen Index ich angebe.

ich kriege keine Fehlermeldung.

[Mivey]

Ich hab mir das mal bei mir lokal angeschaut. (Linux PC)
GCC mag scheinbar UBYTE nicht, ich hab das bei mir mit unsigned char ersetzt und den Code laufen lassen.

Die Einträge von main[] (den Namen lässt gcc btw nicht zu, ist global wohl für die Main-Funktion reserviert, die kann ja als pointer referenziert werden)
werden korrekt ausgegeben. Die ersten 10 oder 20 sind ja genau "0x00", probier mal den ersten Pointer zu verändern, und schau ob dann g.array[0] nicht auch die neue Zahl anzeigt.

[Raildex]

der Variablenname is natürlich nur provisorisch und is selbstverständlich anders.
Array[0] zeigt immer 0.
Komischerweise ist sizeof(g.array) = 2.

[Mivey]

der Variablenname is natürlich nur provisorisch und is selbstverständlich anders.
Array[0] zeigt immer 0.
Ich darf also annehmenn, dass du probiert hast den ersten Eintrag von main[] zu ändern? Bei mir lokal funktioniert das erwartungsgemäß.
Welches System benutzt du und welchen Compiler?

Das sizeof(g.array) gibt dir in Byte die Größe von UBYTE * zurück. Das muss eigentlich 4 sein, wenn es 32-Bit Pointer sind.

[Raildex]

Achso na klar. ich nutze das Gameboy Development Kit GBDK. der gameboy is natuerlich ein 8 Bit System und ne Adresse nutzt 2 Bytes.

[Mivey]

Achso na klar. ich nutze das Gameboy Development Kit GBDK. der gameboy is natuerlich ein 8 Bit System und ne Adresse nutzt 2 Bytes.
Hättest du vielleicht gleich am Anfang erwähnen sollen. ^^"
Was du hier tust ist ja schon sehr hardware-nahes Zeug, und die Frage stellt sich, wie Standard-Konform der Compiler für den GameBoy wirklich ist. Schau dir doch mal die Dokumentation des SDK etwas genauer an.
Da kenn ich mich überhaupt nicht aus, und hab auch kein Interesse mich zu infomieren^^

[Raildex]

Die Dokumentation gibt keinen Hinweis über Pointer.
Wenn ich Pointer ganz normal nutze, funktioniert das auch, nur eben als ArrayMember in einem Struct funktioniert das nicht.