WCM Forum - C-Programm-fehlerhaft?

WCM Forum (http://www.wcm.at/forum/index.php)

- Programmierung (http://www.wcm.at/forum/forumdisplay.php?f=17)

- - C-Programm-fehlerhaft? (http://www.wcm.at/forum/showthread.php?t=116221)

also dann geht jetzt alles?

gut so, also wennst mal hilfe brauchst pn oder mail an mich.

have phun

ja danke und keine angst ich werde noch ne menge threads zum c-thema aufmachen, weil manche sachen irgendwie verwirrend sind ;)

aber es lohnt sich wirklich, hier kriegt man wenigstens plausible erklärungen :)

Anstatt: --> exit(0); /* exit ist eine Funktion die ein spezielles CPU Register mit dem Argument - hier numerisch "0" - füllt und das laufende Programm ordnungsgemäß beendet (inklusive automatischem Dateien schliessen und Speicher freigeben), nicht so bei abort(x); */

Schreib einfach: --> system("PAUSE"); /* dann wartet er bis Du eine Taste drückst und geht dann erst wieder in die IDE - (Integrated Developer Environment) oder auch Shell genannt - zurück */

Du willst ja, daß die Ausgaben, die das Programm macht, am Bildschirm stehen bleiben, und keine erzwungene Programmbeendigung mittels der Funktion exit(x); durchführen.

return 1;

Man kann mittels "if errorlevel 1 echo Rückgabewert ist größer gleich 1" (= if(errorlevel>=1) ) den Rückgabewert eines EXE oder COM Programms in einer DOS Batch Datei abfragen.

So kann man eine Steuerung (mittels goto) innerhalb einer Batchdatei hinbekommen.

Siehe help bei den DOS Befehlen ...

mfg Kikakater

gibts wo ne liste wo die main funktion deatiliert erklärt wird?

meine zb. main () int main() void main (void) etc. merci.

da brauchst net viele beschrieben

diese 2 möglichkeiten sind richtig

int main ()
int main (void)

die 2te ist eigentlich die schönere von beiden

das int hat den sinn, dass das system den rückgabewert weiß
zB 0 wenn das prog erfolgreich beendet wurde

void, bzw. hier dann deklarierte variablen werden beim aufrauf übergeben.

Zitat:

Original geschrieben von noble
da brauchst net viele beschrieben

diese 2 möglichkeiten sind richtig

int main ()
int main (void)

die 2te ist eigentlich die schönere von beiden

das int hat den sinn, dass das system den rückgabewert weiß
zB 0 wenn das prog erfolgreich beendet wurde

void, bzw. hier dann deklarierte variablen werden beim aufrauf übergeben.

:confused: :verwirrt:

also i kapier da was nicht. eins weiss ich, main() scheint irgendwie zu wenig zu sein, aber ich hab halt schon die variante: void main (void) und die var. int main (void) gesehen aber worin ist da der unterschied??

Zitat:

Original geschrieben von noble

diese 2 möglichkeiten sind richtig

int main ()
int main (void)

kenn eigentlich nur die erste, was das void in der Klammer heißt würd mich auch interessieren...

Aba es gibt da eine ganz gute C-Seite, die auch Linux und Perl Programmierung behandelt. Dachte ich teil euch die mal mit: http://www.pronix.de

MfG
PredeX

@Bastet
vielleicht hilft dir das:

Zitat:

http://www.peacesoftware.de/ckurs2.html

2. Die Funktion main

Die zweite Zeile unseres Programmes lautet:

int main(void)

Die Funktion main ist der Anfangspunkt unseres Programmes. Ab hier geht es los. jedes ausführbare C Programm hat eine main Funktion. Gibt es auch nicht-ausführbare C Programme? Ja klar, z. B. Libraries, Hardware Treiber usw.. Diese werden von anderen Programmen aufgerufen und ausgeführt und enthalten keine main Funktion. Dies bedeutet auch das main ein reserviertes Key-Wort ist, es ist strikt verboten eine eigene Funktion oder Variable main zu nennen.

Was ist eigentlich eine Funktion?
Eine Funktion ist ein zusammengehörender eigenständiger Teil eines Programmes. Funktionen können von anderen Orten des Programms aufgerufen werden. Sie können sich übrigens auch selber aufrufen, das nennt man dann "Rekursion". Wann ist es sinnvoll Funktionen zu programmieren? Am einleuchtensten ist es, bei sich im Programm wiederholenden Teilen. Ein typisches Beispiel sind die in der MathLibrary gesammelten Funktionen wie z. B. y = sin(x) etc.. Aber auch zum modularisieren des Programmes ist es sinnvoll Funktionen einzuführen. Eine alte Faustregel sagt, wenn der Code länger als eine DIN A4 Seite wird, sollte man ihn in wegen der Übersichtlichkeit in zwei Funktionen aufteilen, man muss sich aber nicht daran halten.

Funktionen haben einen Namen, einen Rückgabewert (immer, anders als in Pascal wo procedure eine Funktion ohne Rückgabewert bedeutet) und eine Liste von Eingabe Variablen. Wenn eine Funktion "nichts" ausgeben wird, dann gibt sie "void" zurück, dies muss aber deklariert werden. Void bedeutet "nichts". In unserem Falle der main-Funktion.

int main(void)
{
..
}

wird von der Funktion ein int - ein Integer Wert, eine ganze Zahl - ausgegeben int main(void),

und nichts geht in die Funktion hinein int main(void) .

Nach dem Funktionskopf (function head), int main(void) kommt der in geschweiften Klammern {..} der Funktionsrumpf(body of function), in dem die eigentliche Arbeit passiert. Funktionen in die nichts hineingeht und aus denen nichts herauskommt, z.B. void myFunction(void), können also trotzdem etwas ausführen, nämlich das, was in ihrem Funktionsrumpf steht.

Wenn man eine Funktion definiert dann muss man

1) der Funktion sagen von welchem Typ der Rückgaberwert ist

zB

Code:

int addieren (void){

   return 5 + 5;

}

2) man muss definieren welche Werte an die Funktion übergeben werden. Werden keine übergeben dann () oder (void)

zB

Code:

int main (void){

.

.

.

   printf("Ergebnis= %d", addieren (x, y);



.

.

}



int addieren (int x, int y){

   return x + y;

}

main()

ist das gleich wie

int main (void)

void bedeutet es wird kein Wert vom Betriebssytem übernommen.

void im allgemeinen bedeutet kein Datentyp.

void *Zeigervariable;

bedeutet, daß der Variablen Zeigervariable Adressen jeglicher Zeigervariableninhalte zugewiesen werden können.

char *Zeichenkette,*String_4711;

int *Zeiger_auf_Lottoziehungszahl;

Zeigervariable= Zeichenkette;

Zeigervariable= String_4711;

Zeigervariable= Zeiger_auf_Lottoziehungszahl;

(Das) Ist alles möglich - lediglich das

Zeiger_auf_Lottoziehungszahl= String_4711;

ist nicht erlaubt, weil die Datentypen auf die die Zeigervariablen zeigen, unterschiedlich sind.

Wenn man an der Eingabeaufforderung - dem DOS Prompt ist gemeint oder an der Linux Shell - folgendes eingibt:

bastet_prg_maxipraxihaxi parameter1 2 3 4 parameter5

so muß / sollte man main folgendermaßen definieren um auf diese Strings (fünf an der Zahl, nämlich): "parameter1" "2" "3" "4" "parameter5" (ohne Anführungszeichen natürlich, NAAHHHH, bastet Du machst mich schwach !) in der Funktion main zugreifen zu können:

int main ( int argc, char **argv )

oder

int main ( int argc, char *argv[] )

Variante 1 deklariert argv als Zeiger auf einen Zeiger und darob ein Array von Strings.

Variante 2 deklariert argv als Feld (=Array) von Strings.

Ein String hat eine Anfangsadresse und wird so implementiert:

char *zeigervariable;

oder

char zeichen_array_oder_auch_string_genannt[20]

bzw. ohne Längenangabe:

char zeichen_array_oder_auch_string_genannt[]

Ohne Längenangabe kann man (muss man) ein Char Array in einem Funktionskopf deklarieren.

argc beinhaltet 6 Argumente, nämlich den Programmnamen "bastet_prg_maxipraxihaxi" und die 5 eingegebenen Worte ("parameter1" bis "parameter5", dazwischen "2" "3" und "4" :D *herum[schüchter|drucks] ich tu*)

Also:

Code:

int main ( int argc, char **argv )

{

 int i;



 for(i=0; i<argc; i++)

  printf("Argument %d:%s<\n",i,(*argv)++);



 return 0;

}

Soll argc und argv in jeder Funktion nutzbar sein, kann man deren Werte (also den integer Wert von argc sowie den Adresswert der Variablen argv) an globale Variablen übergeben.

Code:

int ich_machs_jetzt_in_einer_funktion (void); /* Prototyp */



int g_argc;

char **g_argv;



int main ( int argc, char **argv )

{

 /* bitte nicht vergessen, sonst stürzt das Programm unweigerlich ab - u.U. zumindest */

 g_argc= argc;

 g_argv= argv;



 ich_machs_jetzt_in_einer_funktion();



 return 0;

}



int ich_machs_jetzt_in_einer_funktion (void)

{

 int i;

 char **l_argv= g_argv; /* lokale Zeigervariable, vielleicht brauchen wir den ursprünglichen Wert

der globalen Zeigervariablen g_argv ja noch,

deswegen g_argv hier nicht verändern */



 for(i=0; i<g_argc; i++)

  printf("Argument %d:%s<\n",i,(*l_argv)++);



 return 0;

}

mfg Kikakater