![]() |
C-Programm-fehlerhaft?
hab gerade mit c-einführung angefangen und da gibts ein übungsbeispiel:
------ #include <stdio.h> main() { ausgabe(2); } ausgabe(wert) int wert; { printf("Mein %d.", wert); printf("C-Programm!"); } ----- witzig daran ist, dass ich damit folgende errors habe: wert+ausgabe - nicht deklarierter bezeichner. main - ergebnistyp wird void angenommen (ok- des hab ich schon kapiert) <unbekannt> funktionsstil-initialisierung scheint eine funktionsdefiniton zu sein. also ich hab einfach mal das übungsbeispiel geändert und es hat anstandslos funktioniert, jetzt schauts so aus: ----- #include <stdio.h> void main() { int ausgabe; ausgabe=2; printf("Mein %d.", ausgabe); printf("C-Programm!"); } ----- jetzt bin ich aber ein bisserl konfus. wieso funktioniert das übungsbeispiel nicht, sondern meine eigene version? oder hab ich irgendwas daran nicht behirnt? |
so sollte es funktionieren:
Code:
#include <stdio.h> http://www.amazon.de/exec/obidos/ASI...778533-6544051 |
ja thx, aber ich kapier einfach nicht wieso das übungsbeispiel fehlerhaft ist, eigentlich sollten die beispiele doch korrekt sein!
bin eh stolz auf mich, dass ich selbst ne andere lösung gefunden hab, schliesslich weisst du ja das wievielte programm es ist :D |
obiges funktioniert nicht, weil das c-programm von "oben nach unten" abgearbeitet wird.
die main funktion "kennt" daher die Funktion <ausgabe> nicht. lösungen: ausgabe funktion vor der main-funktion definieren (schlechte lösung, weil nicht möglich, wenn es mehrere funktionen werden) bessere lösung: die von hewlett - d.h. vor der main funktion einen sog. prototypen der verwendeten funktion(en) definieren. fg + viel spaß noch beim lernen. -hannes |
Das Übungsbeispiel zeigt die ursprüngliche Schreibweise von C Code.
Ohne Prototyp und ohne Angabe eines Datentyps im Funktionskopf ist der Rückgabetyp einer Funktion immer vom Typ int (Compilerannahme). Früher (vor dem Prototyping) hat man die Datentypen von Parametern nach dem Funktionskopf aufgelistet int funktion(p1,p2) int p1; long p2; { ... } Es handelt sich hier um eine alte Schreibweise, die neueren Compilern u.U. Probleme macht. |
Code:
#include <stdio.h> |
herzlichen dank an alle, ihr habt mir sehr geholfen - wieder was kapiert hab. :)
vorallem als neuling ist es zwar noch ein bisschen verwirrend, wenn ma mal alle beispiele betrachtet und eigentlich doch immer aufs selbe ergebnis kommt. da stellt sich nur eine frage - welches beispiel sollte als richtig gelten? ja ich weiss - die logik des programmierens ist zeitweilig unergründlich :lol: ;) |
Zitat:
Code:
ausgabe(2); /* "" werden nur bei Strings (char []) verwendet */ |
C Programme haben keine Empathie. Das heißt, Code zu schreiben ist technisch richtig oder nicht. Etwas hineinzugeheimsen spielt es nicht.
Die Emotion kommt mit dem Designergedanken, mit den Techniken herumzuspielen, im übrigen Bibliotheken zu verwenden. Wichtig sind die Wertebereiche von Datentypen. Sowie die Unterscheidung von Datentypen zu Zeigervariablen, die Adressen beinhalten und EBEN NICHT Daten. Zeigervariablen können auch wiederum auf Zeiger - im Englischen "Pointer" - verweisen (z.B. char **argv <-- Zeiger oder char *argv[] <-- Array (=Feld)). Unterschiedlich zu einem Zeiger ist ein Array. Das Array stellt eine Anfangsadresse von gleichlautenden Elementen oder Kapselschlüssen (Objekte) dar. Einem Arraybezeichner kann keine neue rsp. andere Adresse im Programmlauf zugewiesen werden. Einer Zeigervariablen schon. char c; /* -128 bis +127 */ char *pc; /* Zeigervariable auf ein char Zeichen */ char yc[10]; /* Array mit 9 + 1 Elementen bei Verwendung als C String, sonst 10 Elemente. keine Überlaufprüfung ! */ Dynamische Anforderung von Speicher: pc= malloc(10); /* 10 Bytes anfordern und die Anfangsadresse dieses 10 Byte großen Speicherblocks der Variablen pc zuweisen, pc sollte tunlichst als char *pc; deklariert sein. Alles andere ist unsaubere Programmierung. */ void *pv; pv= pc; Umtypisieren von Daten oder Zeigern: int i; char c; i= (int) c; oder i= c; int *pi; char *pc; pi= (int *)pc; /* Vorsicht ! Dies ist bereits unsaubere Programmierung, und nur erlaubt, wenn man ein zweites (bzw. 3 weitere) Byte(s) hinter *pc (=dem Zeichen auf das die Adresse, die pc speichert, verweist) vorrätig hält. Portabilität: Zeichensatz (Umfang und Sortierreihenfolge) Wertebereich von Datentypen Reihenfolge der Stackargumente bei Funktionsaufrufen Big vs. Little Endian (Lowbyte vor Highbyte und umgekehrt) Interface Schnittstellen (Hüllfunktionen) zur Korrektur bzw. Anpassung von inkompatiblen Daten ~ |
Zitat:
auch wenn ich noch ein exit hinzufüge lt. c compaktreferenz (hab so ziemlich alle exitarten ausprobiert) , dann bekomm ich immer die fehlermeldung : prase error at end of input |
Den Code des Beispielsprogramms zu posten wo eine Endlosschleife auftritt ist die einzige Möglichkeit Dir Bescheid zu geben, warum eine Endlosschleife auftritt.
Die Meldung prase ... müsste wohl parse ... lauten, oder ? Jedenfalls kenn ich mich im Moment nicht aus. Ich vermute diese Meldung schiebt der Compiler beim Compilieren. Poste den Code oder hänge ein Attachment mit der Quelldatei an. |
Code:
#include <stdio.h> ich benütze die entwicklungsumgebung rhide, das ist in djgpp integriert. imho brauche ich ein exit, stimmt es heisst - parse, die meldung bekomme ich beim compillieren, wenn ich lt. c-compaktreferenz versuche ein exit zum beenden des prozesses hinzuzufügen. |
versuche mal:
Code:
int main() |
wenn ich die rechteck.exe starte funktioniert aber alles tadellos :confused: *ich glaub ich bin so dooof* :lol:
aber mich würd schon interessieren weshalb rhide diese meldung schiebt, wenns bei der exe tadellos funktioniert. |
Zitat:
|
OK, also ich hab mal deinen Code versucht in der Enwicklungumgebung Bloodshed.
Die kann ich nur jedem Empfehlen, ist Opensource und ein wahnsinn. also vorerst ist es wichtig das du die MAIN Funktion wie folgt definierst, da sonst probleme mit versch. Compilern auftreten können Code:
int main (void) noch eine Verständnissfrage, führst du das direkt aus der entwicklungsumgebung aus oder gehst in die dos box und rufst dir dort deine EXE auf? |
das problem gibts nur in der entwicklungsebene, in der dos box mit aufruf der exe gibt es absolut kein problem
|
den fehler mir PARSE?
poste oder schick mir den code doch mal so wie er nen fehler gibt. das mit dem exit versteh ich auch nicht ganz, was du da einfügen willst? |
Zitat:
@noble der code steht auf der ersten seite, das problem hat sich gelöst. ich wusste nur nicht wie man die main funktion mit nem exit beendet. in allen übungsbeispielen gibts nämlich keinerlei exit angaben. |
sorry, doppelpost :o |
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:
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:
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:
|
Wenn man eine Funktion definiert dann muss man
1) der Funktion sagen von welchem Typ der Rückgaberwert ist zB Code:
int addieren (void){ zB Code:
int main (void){ |
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 ) Code:
int ich_machs_jetzt_in_einer_funktion (void); /* Prototyp */ |
Zitat:
dam, bis jetzt hab ich immer nur main() oder int main() benutzt naja rhide schreit zwar bei main() aber ich hab keinen error. aba ich hab auch in anderen beispielen int main(void) oder void main (void) gesehen. und jaaa ich hab auch schon genügend links, erklärungen usw. gelesen... aba überall wirds gleich erklärt :o also bitte erklärung für dummies und ned irgendwelche intelligenz voraussetzen ;) {und was dass betrifft: bastet_prg_maxipraxihaxi parameter1 2 3 4 parameter5 wär da nicht besser int bastet_prg_maxipraxihaxi[5] odr. redst wieder mal an mich vorbei? } waaahhh - i muss des einfach kapieren. ajo und da fällt mir ein - hab schon über die zeiger und arrays gelesen, wird aber noch nicht gefordert. des lern ich erst wenn ich die prüfung schaff und den c++ kurs machen darf ;) |
oh mann oh mann, ich glaub mei hirn hat schon nen bluescreen...
sorry, aber ich bin kein meister im erklären, deshalb reden wir scheinbar manchmal aneinander vorbei. soweit ichs behirnt hab: main() der compiler muckt zwar mit info auf und meint er nimmt void an, aber er hat keinen error. also schreib ich halt ab jetzt immer int main(void) - ich hab genügend unterlagen, aber mir fehlt irgendwie dazu eine plausieble erklärung... für dummies ;) keine ausschweifungen in irgendwelche richtungen - einfach nur ne gute erklärung zur syntax. |
Zitat:
Wenn ich dich auf etwas hinweisen darf: Einige Postings vorher warst du bereits bei 'int main' angelangt. Schon vergessen :confused: |
Zitat:
|
kauf dir das buch
C Programmieren von Anfang an ISBN: 3499600749 Das Buch ist das richtige für Anfänger, alles genau erklärt mit Übungen und Aufgaben zum selber lösen und wenn man nciht mehr weiter weiß, steht hinten ne lösung. Das ganze kostet rund 10 Euro und ist das Geld mehr als Wert. |
Zitat:
|
Zitat:
jup, ich weiss, habe in diesem thread schon einige punkte erfragt und antworten bekommen, werde aber demnächst für eigene fragen auch eigene threads aufmachen - deshalb ist wahrscheinlich auch bei manchen verwirrung entstanden ;) aber ich muss sagen dieser thread hat mir schon sehr viel gebracht :) |
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 Dieses komische Ding (bastet_prg_maxipraxihaxi) ist ein Programm ! (sowas wie Excel.exe) sprich bastet_prg_maxipraxihaxi.exe Du sollst also nicht > dir c:\ eingeben sondern > bastet_prg_maxipraxihaxi parameter1 2 3 4 parameter5 im DOS Modus = an der Eingabeaufforderung wenn Du nur > bastet_prg_maxipraxihaxi eingibst so steht im C Programm in der Variablen argc 1 und in der Variablen argv 4 Millionen und irgendwas (eine Adresse also), unter *argv ist die gleiche Adresse + 4 * Anzahl der Argumente zu finden und unter **argv findet sich schließlich ein 'b' (Beginn des Programmnamens bastet_prg_maxipraxihaxi), unter *(argv+1) ist die Adresse + 4 * Anzahl der Argumente + Länge des Programmpfades zu finden, und unter **(argv+1) findet sich das Zeichen 'p' (für parameter1) argv[0] <-- "bastet_prg_maxipraxihaxi" argv[1] <-- NULL sonst argv[0] <-- "bastet_prg_maxipraxihaxi" argv[1] <-- "parameter1" argv[2] <-- "2" argv[3] <-- "3" argv[4] <-- "4" argv[5] <-- "parameter5" für argv[0] kann man auch *argv schreiben für argv[1] *(argv+1) usw. Alles klar ? Code:
#include <stdio.h> |
Zitat:
|
Zitat:
|
Alle Zeitangaben in WEZ +2. Es ist jetzt 13:19 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
© 2009 FSL Verlag