C: Funktion aus externer c-Datei?

[mf_2]

Hallo,

Ich hab vor n paar Tagen mal angefangen, in C zu programmieren.
Jetzt hab ich aber ein Problem: Ich möchte eine Funktion, die mein Starten des Programms abgearbeitet werden muss in eine andere C-Datei auslagern um die Übersichtlichkeit zu behalten.

Die Programmdatei ( core.c ):

--------- START der Datei --------------


int main()
{

printf("################################################################################");
printf("# #");
printf("# Dateiprogramm #");
printf("# #");
printf("# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #");
printf("# #");
printf("# Suche Module .... #");
printf("# #");
modulsuche();
printf("# #");
printf("# Modulsuche beendet #");
getchar();
return 0;
}

--------- ENDE der Datei --------------

Die Datei mit der Funktion ( modulsuche.c ):


--------- START der Datei --------------

#include <stdio.h>
FILE *fp_gl1vok;
FILE *fp_gl2vok;
FILE *fp_gl3vok;
FILE *fp_gl4vok;
FILE *fp_gl5vok;
FILE *fp_gl6vok;

int modulsuche(void)

{

if ((fp_gl1vok=fopen("gl1_vok.h","r"))==NULL)
{
printf("# 1 ................................. nicht vorhanden #");
}
else
{
printf("# 1 : ....................................... vorhanden #");
}

if ((fp_gl2vok=fopen("gl2_vok.h","r"))==NULL)
{
printf("# 2 ................................. nicht vorhanden #");
}
else
{
printf("# 2 : ....................................... vorhanden #");
}

if ((fp_gl3vok=fopen("gl3_vok.h","r"))==NULL)
{
printf("# 3 ................................. nicht vorhanden #");
}
else
{
printf("# 3 : ....................................... vorhanden #");
}

if ((fp_gl4vok=fopen("gl4_vok.h","r"))==NULL)
{
printf("# 4 ................................. nicht vorhanden #");
}
else
{
printf("# 4 : ....................................... vorhanden #");
}

if ((fp_gl5vok=fopen("gl5_vok.h","r"))==NULL)
{
printf("# 5 ................................. nicht vorhanden #");
}
else
{
printf("# 5 : ....................................... vorhanden #");
}

if ((fp_gl6vok=fopen("gl6_vok.h","r"))==NULL)
{
printf("# 6 ................................. nicht vorhanden #");
}
else
{
printf("# 6 : ....................................... vorhanden #");
}

return 0;
}


Dieses Programm soll erstmal nur prüfen, ob bestimmte Dateien vorhanden sind und die passende Meldung ausgeben.

Jetzt kommt aber mein Problem:
Wenn ich das Ganze mit dem Borland C++ Builder 1.0 compiliere, bekomme ich den folgenden Fehler:

[C++ Warning]MODULSUCHE.C(11): Cannot create pre-compiled header: code in header.

Könnt ihr mir sagen, was ich falsch mache?

[mrdigital]

schreib ein Headerfile, in dem nur die Funktionsköpfe drinnstehen

modulsuche.h
#ifndef __modulsuche__
#define __modulsuche__

#include <wasimmerdubrauchst>
#define MEINE_DEFINES sollten hier stehen

int GlobaleVariablen;

int IchBinEineLustigeFunktion(int Parameter);
#endif
-------
modulsuche.c

#include modulsuche.h
int IchBinEineLustigeFunktion(int Parameter)
{
return Parameter*Parameter;
}




und in deinem core.c

#include modulsuche.h

int main()
{
int a;
a = 1;
a = IchBinEineLustigeFunktion(a);
}

[mf_2]

Hallo,

Danke erstmal, aber einige Sachen versteh ich nicht:

Was ist MEINE_DEFINES?

Was bringt mir die modulsuche.c?
Welche Parameter soll die zurückgeben?

Ich ahtte mir das so gedacht ( es kann gut sein, dass ich flasch liege, da ich ein c-neuling bin ):
Der computer führt die core.c aus, und wenn die modulsuche() verlangt wird, springt er in die modulsuche.c ( oder eben .h ) und führt die modulsuchefunktion in der datei aus, um dann wieder an der stelle im core weiterzumachen, an der er vorher aufgehört hatte. die modulsuche-funktion gibt ja nur evtl. was auf den bildschirm, sie soll ja nichts berechnen o.ä.m, also braucht sie doch glaube ich auch keinen return-wert ( also return 0 ), oder liege ich flasch? Wie gesagt, vielleicht mache ich mir das zu einfach, ich programmiere erst seit kurzem in c.

Hoffentlich seit ihr schlauer als ich.

[zeckensack]

Okay, nochmal von vorn.
Du brauchst drei Dateien.

1)modulsuche.h
/*das ist eine Funktionsdeklaration: */
int modulsuche();

2)modulsuche.c
#include <stdio.h>
#include "modulsuche.h"

/*das sind globale Variablen: */
FILE *fp_gl1vok;
FILE *fp_gl2vok;
FILE *fp_gl3vok;
FILE *fp_gl4vok;
FILE *fp_gl5vok;
FILE *fp_gl6vok;

/*das ist eine Funktionsdefinition: */
int modulsuche(void)
{

if ((fp_gl1vok=fopen("gl1_vok.h","r"))==NULL)
{
printf("# 1 ................................. nicht vorhanden #");
}
else
.
.
.

3)core.c
#include <stdio.h>
#include "modulsuche.h"

int main()
{

printf(" ################################################################################
");
printf("# #");
printf("# Dateiprogramm #");
printf("# #");
printf("# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #");
printf("# #");
printf("# Suche Module .... #");
printf("# #");
modulsuche();
printf("# #");
printf("# Modulsuche beendet #");
getchar();
return 0;
}

Der Compiler kompiliert jede .c-Datei separat. Wenn du in einer C-Datei eine Funktion aus einer anderen C-Datei nutzen willst, musst du sie dem Compiler bekannt machen. Deswegen die Deklaration im Header, aber noch nicht der vollständige Code (aka die "Definition" der Funktion). Dadurch weiss der Compiler gerade genug über die Funktion, um Code zu erzeugen, der sie korrekt aufrufen kann.

mrdigital hat in den Header noch sogenannte "inclusion guards" eingebaut, die kurz gesagt verhindern, dass ein Header von einer C-Datei mehrfach eingebunden werden kann (mehrfache Deklarationen sind nämlich Fehler!).

Etwas genauer, der Header kann trotzdem noch eingebunden werden, der Präprozessor filtert aber bei Wiederholungen den gesamten Inhalt einfach weg.

#ifndef __bin_schon_da__
#define __bin_schon_da__ /*fuer den nachsten Durchlauf */

/*eigentlicher Inhalt des Headers */
.
.
.
#endif

Ob man in Headern weitere Header einbindet (wie in deinem Fall <stdio.h> ), ist mehr oder weniger eine Frage des persönlichen Geschmacks. Ich tue es jedenfalls nicht.

[mrdigital]

Zecki, ich dachte, dass das was du "Funktionsdefinition" nennst, ist eigentlich die "Funktionsimplementierung" *über die Begriffe rätsel*
Gruss

[Xmas]

Original geschrieben von mrdigital
Zecki, ich dachte, dass das was du "Funktionsdefinition" nennst, ist eigentlich die "Funktionsimplementierung" *über die Begriffe rätsel*
Gruss
Ist ja auch dasselbe. Der Funktionsprototyp ist die Deklaration.

[Xmas]

mf_2,
eine Funktion die nichts zurückgeben soll, sollte auch den Rückgabetyp void haben. Dementsprechend steht am Ende auch nur return; oder gar nichts.

Für die Modulsuche solltest du eine Schleife verwenden. Wozu benötigst du die Filehandles noch? Wenn du die außerhalb von modulsuche() nicht mehr brauchst, sollten sie auch lokal in der Funktion deklariert werden. Und wer öffnet, sollte auch wieder schließen ;)

[mrdigital]

Original geschrieben von Xmas
Ist ja auch dasselbe. Der Funktionsprototyp ist die Deklaration.

so wie ich dachte, ist Deklaration = Definition = "Prototyp" und der Rest ist dann die Implementierung. Aber das ist nun ja reichlich "akademisch" ;)

[zeckensack]

Original geschrieben von mrdigital
Zecki, ich dachte, dass das was du "Funktionsdefinition" nennst, ist eigentlich die "Funktionsimplementierung" *über die Begriffe rätsel*
Gruss Definition und Implementierung halte ich für austauschbar. Implementierung ist der eigentlich korrektere Begriff, und in allen möglichen Feldern gebräuchlich.
Im Compiler-Bereich redet man IMO öfter mal von Definition, kA warum. Ich wollte hier nur den Begriff verwenden, der voraussichtlich auch in der Literatur auftauchen wird.

Deklaration ist aber auf jeden Fall etwas anderes als Defintion.

Definition: komplett festnageln, inklusive Code

Vgl:
Student: Ich bleibe heute zu Hause, ich fühle mich etwas unwohl.
ÜGL: Definiere "etwas unwohl".
:D

[mf_2]

Danke, jetzt funktioniert alles. :) Ihr seid echt schlau!

[mf_2]

So, ich hab schon wieder ein Problem:

Ich habe eine Zahl in einer Variable gespeichert.
Die Variable nennt sich "zahl".

jetzt möchte ich eine datei mit fopen öffen.
die datei heisst datei'einezahl'.h.
Die zahl für den dateinamen findet das programm in der zahl-Variable.
Nun meine Frage:
Wie kann ich den Inhalt einer Variable in die fopen-Anweisung schreiben.
Mir fällt da spontan nur php mit seiner "text".variable."text"-schreibweise ein, aber bei c funzt das nicht :D
und %d kann ich ja auch vergesssen, da das ja nur für printf gilt, oder?

[Gnafoo]

int zahl = 10;
char filename[255];

sprintf(filename, "datei%i.h", zahl);

FILE* pFile = fopen(filename, "r");
// ...
fclose(pFile);


so in etwa

[mf_2]

Danke, noch ne Frage:

Gibt es in C eine Funktion, die einen String anhand bestimmer Zeichen aufteilt und als Array speichert? So etwas wie explode() in php.

[Gnafoo]

Ist mir nichts bekannt. Wahrscheinlich musst du das schon
selber machen, wobei ein Array an Strings in C auch nicht
ganz unproblematisch ist, da Strings selber in C ja schon
Arrays von chars sind.

[aths]

Original geschrieben von Der Tod
Ist mir nichts bekannt. Wahrscheinlich musst du das schon
selber machen, wobei ein Array an Strings in C auch nicht
ganz unproblematisch ist, da Strings selber in C ja schon
Arrays von chars sind.

cu Der Tod Das geht trotzdem. Oder man schreibt sich eine eigene String-Klasse, bzw. sucht sich freie String-Klassen.

edit: Ist ja C, und nicht C++ :bonk: :freak: