Verfügbare Informationen zu "Neue C-Befehlssammlung"
Qualität des Beitrags: Beteiligte Poster: Kloetengott - marc Forum: www.ITF04-bochum.de.vu Forenbeschreibung: Alles rund um ITF04 usw aus dem Unterforum: AWD Antworten: 2 Forum gestartet am: Dienstag 07.09.2004 Sprache: deutsch Link zum Originaltopic: Neue C-Befehlssammlung Letzte Antwort: vor 18 Jahren, 6 Monaten, 6 Tagen, 9 Stunden, 36 Minuten
Alle Beiträge und Antworten zu "Neue C-Befehlssammlung"
Re: Neue C-Befehlssammlung
Kloetengott - 20.09.2004, 09:15Neue C-Befehlssammlung
Und es wird auch weiterhin geupdated :-)
würde mich allerdings über ein wenig response freuen damit ich weiss das ich den ganzen scheiss hier nicht für die Katz mach...
Code: #include <stdio.h> muss am anfang des C-Quelltextes stehen damit die Bibliotheken für die Befehle geladen werden
#include <stdlib.h> erweiterte Bibliotheken für zusätzliche C-Befehle
#include <time.h> Befehle für Zeiterfassung, Uhrzeitfunktionen und einfache Zeitausgabe
void main() main eröffnet die Hauptfunktion in dem jeweiligen Programm. Die gesamte Funktion muss in geschweiften Klammern stehen! Die runden Klammern hinter main sind dazu da evtl. Werte an andere Funktionen zu übergeben, diese bleiben aber bei einfachen Programmen meist leer!
Funktionen müssen mit einer geschweiften Klammer {} geöffnet und wieder geschlossen werden!
Einzelne Befehle und Anweisungen müssen immer mit ; beendet werden
Kommentare werden mit //"Kommentar" ans ende der Zeile geschrieben. Der Compiler "überliest" Kommentare einfach
Variablennamen:
---------------
Um Variablen im Programm einsetzen zu können müssen diese am anfang immer IN (lokal) oder VOR der funktion (global) deklariert werden!
Die Namensgebung der Variablen unterliegt ein paar Regeln:
-mindestens ein Buchstabe
-Variablennamen dürfen nicht mit einer Zahl beginnen
-keine Leerzeichen, benutzt Unterstrich
-verwenden sie keine C-Schlüssenwörter wie zB: int
-möglichst kurze Namen und keine Sonderzeichen (am besten immer kleinschreiben)
-Grossschrift wird für konstante Variablen empfohlen!
Die einzelnen Variablen haben folgende Namen und Bedeutungen:
char name[20]; erstellt speicherplatz von einer grösse von 20 zeichen für die variable "name". Ist ein String!
char name; erstellt Speicher für ein zeichen.
int name; erstellt speicherplatz für eine ganze zahl mit dem namen "name"
float name; erstellt speicherplatz für eine fliesskommazahl mit dem namen "name"
double name; erstellt speicherplatz für eine fliesskommezahl mit doppelter genauigkeit (doppelt so lang)
const wird vor eine variablendeklaration das wort const geschrieben, so ist die variable ab jetzt ein konstante, der wert ändert sich nicht mehr!
Um eine Variable in zB: printf korrekt ausgeben zu können, muss auch der korrekte Variablenplatzhalter eingesetzt werden.
%s = gibt String aus der vorher zB: duch "char name[20]" festgelegt und dann eingelesen wurde.
%c = gibt ein einzelnes Textzeichen aus
%i = "int" zahl = eine ganze zahl (Intergerzahl) die einen wert von -2.147.483.648 bis 2.147.483.648 haben kann.
%u = "int" zahl ohne Vorzeichen
%f = "float" zahl = eine fliesskommezahl, wird auch benutzt um double auszugeben!
Befehle in C:
-------------
Einlesen eines Strings:
gets(name); liest einen textstring (nur text!) von der tastatur ein und speichert ihn in der variablen "name" ab.
scanf("Platzhalter für Variable", &name für variable);
liest text von der tastatur in eine variable ein. kann text sowie zahlen usw einlesen.
name getchar(); liest ein einzelnes zeichen von der Tastatur ein und speichert es der char-variablen "name"
getchar(); liest ein zeichen von der tastatur ein (speichert es aber nirgendwo, funktioniert eigentlich eher als pause im Programm bis jemand was eintippt)
fflush(stdin); alle zeichen aus der eingabewarteschlange löschen (nützlich bei Programmen die eine oder mehrere eingabeaufforderungen erwarten)
Ausgabe:
puts("text"); oder gibt einen unformatierten text aus (muss in "" stehen) und macht dann einen zeilenwechsel
puts(variable); gibt eine vorher deklarierte variable aus und macht deinen einen zeilenwechsel
printf("text, platzhalter für variable1, text, platzhalter für variable2", name variable1, name variable2);
gibt formatierten text aus (text bei dem man bestimmte eigenschaften vorgeben kann) und kann variablen ausgeben die im text von platzhaltern ersetzt werden, und am ende des textes durch die variablennamen "ersetzt" werden.
zusätzliche formatierungen:
zB:
%15s verschiebt den string um 15 zeichen nach rechts
%-15s verschiebt den string um 15 zeichen nach links
escapesequenzen: geben zeichen aus oder haben bestimmte funktionen innerhalb von printf. Sie müssen zwischen den "" stehen!zb:
\a lautsprecher piepst
\n zeilensprung
\" anführungszeichen
\? fragezeichen
\t tabulatorsprung
\r cursor an den zeilenanfang setzen
\x084 ä
\x094 ö
\x081 ü
\x08e Ä
\x099 Ö
\x09a Ü
\x0e1 ß
\0128 Euro?
Umwandeln in eine echte Zahl: (Damit Rechnungen möglich werden)
Achtung: alle Zahlen müssen erst mit zB: atoi oder atof umgewandelt werden bevor sie einen echten Wert haben!
Vorher haben sie eine Bezeichnung, das heisst C sieht ihre Bedeutung genauso wie es ein "e" sehen würde. Ohne wertinhalt!
intname = atoi(string); nimmt einen string und wandelt ihn mit der "atoi" funktion in eine integer-zahl um. wird dann dem "atoi" intnamen zugewiesen
floatname = atof(stringname); wandelt eine string-zahl mit hilfe von atof in eine echte fliesskommazahl um
"atof"
Rechnen in C:
In C kann fast überall gerechnet werden zB: als seperate Funktion: zahl1 = zahl2 + zahl3;
oder innerhalb eines strings: ("%i + %i = %i", zahl1, zahl2, zahl1 + zahl2);
Oder auch innerhalb von Schleifen, for/else bedingungen usw... (kommt später).
Grundrechenarten sind: +, -, *, /, %. (% = teilen einer zahl mit restwertausgabe)
Bedingungen, Schleifen und Wiederholungen:
if (wert1 > wert2){"funktion"} if fragt etwas ab und führt die folgenden Anweisungen dann aus wenn es zutrifft.
zB: vergleicht es ob wert1 grösser ist als wert2. Wenn ja (true), werden die Anweisungen innerhalb der geschweiften Klammern ausgeführt.
Vergleiche: Folgende Vergleiche sind in C erlaubt: a > b (a grösser b), a < b (a kleiner b), a == b(a gleich b), a >= b (a grösser/gleich b), a <= b (a kleiner/gleich b) und a != b (a ungleich b).
Es können auch Zeichen verglichen werden, diese müssen dann nur in Hochkommas gesetzt werden! zB: (variablenname == 'a'). Der Vergleich ist wahr wenn in der Variablen das Zeichen "a" steckt!
Es können auch die Buchstabenwerte verglichen werden, da jeder Buchstabe eigentlich ein Ascii-Wert ist (internationale Zeichentabelle). a zB: hat den ascii-wert 097. also: (variable > 'a') ist dann wahr (true), wenn der ascii-wert des Buchstaben in der Variablen grösser ist.
else if (wert2 > wert1){"funktion"} else if wird ausgeführt wenn die erste if-Bedingung nicht zutrifft! Trifft die else if Bedingung dann zu, wird die Funktion in else if Ausgeführt!
else {"funktion"} else tritt ein wenn if und else if nicht zutrifft! else führt dann alle Anweisungen in den geschweiften Klammern aus.
for (zahl = 0; zahl < 3; zahl = zahl + 1) {"funktion"}
for beginnt eine einfache Schleife. Dabei wird die Funktion in den geschweiften Klammern so oft wiederholt, wie in den runden Klammern angegeben ist. Erklärung: Die Variable "zahl" wird auf 0 gesetzt (zahl = 0), dann wird bei jeder for-Wiederholung "zahl" um 1 erhöht (zahl = zahl + 1). Das ganze wird solange wiederholt, wie "zahl" kleiner als 3 bleibt (zahl < 3). Ist "zahl" 3 oder grösser ist die Schleife beendet.
for (;;) {"funktion"} Da für diese Schleife keine Start und Endbedingungen gesetzt werden, ist sie eine Endlosschleife!
break; wird innerhalb einer Schleife irgendwie break aufgerufen, wird die Schleife sofort beendet!
Abkürzungen:
Vieles in C kann man abkürzen, zB beim rechnen:
int1 = int1 + 1; Eins dazuzählen nennt man Inkrementieren. Das geht auch kürzer: int1++;
int1 = int1 - 1; Eins abziehen nennt man Dekrementieren. Kurze Version: int1--;
int1 = int1 + 5; Fünf addieren. Kurz: int1 += 5;
int1 = int1 - 5; fünf abziehen. Kurz: int1 -= 5;
int1 = int1 * 5; mit fünf multiplizieren. Kurz: int1 *= 5;
int1 = int1 / 5; Durch fünf Dividieren. Kurz: int1 /= 5;
Funktionen schreiben:
---------------------
In C kann man seinen Quelltext erheblich kürzen indem man Dinge die man häufiger braucht nicht immerwieder schreibt, sondern einfach eine eigene Funktion dafür schreibt und sie dann später im main-programmteil aufruft.
Funktionen müssen noch vor der Hauptfunktion geschrieben werden, also vor main! zB:
void lalala(void)
{"viele anweisungen usw."}
void main().........
Damit hat man vor main eine eigene Funktion mit dem Namen "lalala" entworfen. Die Funktion übergibt keinen wert an andere Funktionen und bekommt auch keinen wert von anderen funktionen da in und vor den Klammern void steht (leer).
Man kann hier nun genau wie in der Hauptfunktion Anweisungen, Printausgaben, Schleifen, Rechnungen usw. einbauen.
In der Hauptfunktion kann man nun die vorher geschrieben Funktion wie einen Standart C-Befehl ausführen, in diesem Fall mit lalala();
Eine Funktion kann einen Wert haben den sie weitergibt und auch Werte zugewiesen bekommen! zB:
int lalala(int wert1, int wert2, float wert3)
{"viele anweisungen usw."}
In der main funktion muss lalala nun nicht mehr so "lalala();" geschrieben werden, sondern es muss die werte die es braucht in der richtigen Reihenfolge zugewiesen bekommen! Es können auch einfach Variablen genommen werden. zB:
lalala(23, zahl5, 12.55);
Achtung: hier heisst die zweite Variable "zahl5". Sie hat diesen Namen innerhalb der main-funktion! Innerhalb der lalala-funktion haben wir ihr den Namen "wert2" zugewiesen! In der lalala-funktion muss also mit "wert2" gearbeitet werden und nicht mit "zahl5"! Um verwirrungen zu vermeiden empfehle ich einfach die selben Variablennamen zu verwenden.
Da die Funktion lalala am anfang als int-funktion deklariert wurde, gibt sie einen int-wert zurück!
Folgendes wäre also in der Hauptfunktion möglich:
wert1 = lalala(23, zahl5, 12.55);
Funktionen bekommen Variablen, arbeiten mit ihnen, und geben dann etwas zurück, zB: eine int-zahl (alles andere geht auch)
Kompliziert... nochmal lesen! gerallt?
Weitere C-Befehle:
------------------
intname = rand(); Der Int-variablen wird ein zufälliger Wert von 0-32767 zugewiesen. (rand=random=zufall)
srand("zahl"); mit srand kann man eine zahl nehmen die den zufallsprozess für rand noch weiter erhöht.
srand(6); sorgt zB: dafür, das rand andere zahlen erzeugt als es dies ohne zahlenzugabe tun würde.
srand((unsigned)time(NULL));
zahl = rand() % 31 + 1; erzeugt eine zufällige Zahl aus der Zeitangabe von 1-31 und speichert sie in "zahl"
time kann mit printf und %i ausgegeben werden. zeigt die aktuelle zeit an und fordert dann eingabe der neuen zeit (benötigt <time.h> include)
#define name befehl mit define kann man sich seine eigene befehlsstruktur zusammenbauen. Man definiert zB: das Wort Ausgabe so, das es einen printf-befehl hervorruft: #define Ausgabe printf. Sollte direkt unterm header stehen.
exit(0); ermöglichst es das Programm an jeder beliebigen stelle sofort zu beenden.
Eingaben in der Kommandozeile:
------------------------------
Jedem in C Programmierten Programm können Parameter übergeben werden zB: start.exe blabla muhmuh nene. Hiermit würden dem Programm start 3 Parameter übergeben die im Programm etwas bewirken können. Dazu muss die main-funktion verändert werden:
void main(int argc, char* argv[])
klingt böse, ist einfach: "int argc" ist einfach eine int-variable die die Anzahl der Paramter zählt (argc = argument count, also Argumentzähler). Je nach Anzahl werden genügend Strings von "char* argv[]" geschaffen um jedes Argument einzeln darin abzuspeichern. argv[1] wäre also blabla, argv[2] wäre muhmuh und argv[3] wäre nene.
Achtung: argc ist immer mindestens 1, weil es den Programmnamen selbst mitzählt. argc würde also in unserem Beispiel 4 Argumente zählen, obwohl es nur 3 sind!
Mit den Argumenten kann man dann ganz normal in C arbeiten, zB: if(argv[1]== 'blabla')......
PS: zeilenumbruch und tabs funktionieren mal wieder nicht, deshalb siehts arg durcheinander aus...
wär schön wenns mal irgendwer vernünftig uploaden und dann linken könnte...
Re: Neue C-Befehlssammlung
marc - 20.09.2004, 14:11links
hier nen link zu nem c online buch
http://pronix.de/modules/C/openbook/
und ein recht gutes tutorial
http://www.c-plusplus.de/tuts/c/c_ivo.zip
Mit folgendem Code, können Sie den Beitrag ganz bequem auf ihrer Homepage verlinken
Weitere Beiträge aus dem Forum www.ITF04-bochum.de.vu
Ähnliche Beiträge wie "Neue C-Befehlssammlung"
