Programmiersprache C – Formular

#include<nome.libreria>
#define NOME.COSTANTE wert.konstant

main() {…körper.programm…} /*Hauptfunktion, die das Programm einführt*/

{…die Graffiti dienen dazu, eine Reihe von Anweisungen zu enthalten…}

Deklarationen von Variablen: typ name.variable

Tipi:
intintero;float4numeri.dopo.virgola (doubledoppio.float);charcarattere;voidqualsiasi.tipo;

Anleitungen
/*’;’ um die Funktion abzuschließen*/

printf("testo.o.%.simbolo.variabile", nome.variabile); /*Ausgabe, drucke Wert (stdio.h)*/

simboli di stampa (\): \n va a linea nuova

springt eine Tabulatorstelle
\b kehrt ein Zeichen zurück (Löschen nach hinten)
Die Hupe des Autos ertönt.
\ drucke das Zeichen \
" drucke das Zeichen "

scanf("%simbolo.variabile", &nome.variabile); /*Eingabe, Wert lesen (stdio.h)*/

variablen Symbole (%): %d, Ganzzahlen

%c, Zeichen
%f, float
%s, Zeichenfolge (Zeichensequenz)

getch(); /*blockiert das Programm und wartet auf eine Eingabe von der Tastatur */
(conio.h)*/

return 0; /*restutuisce valore, compatibile

conint main()*/

pow(); sqrt(); /*elevamento a potenza; radice*/

Zuweisung

= : weist der Variablen einen Wert zu (numerisch oder einer anderen Variablen)

x = a; /*assegnamento a x del volore di a*/

x = 4;
x = ‘a’; /*Zuweisung Zeichen*/
x = (x+y)*(a/b); /*Zuweisung des Wertes Ergebnis einer Operation*/
x++; x--; /*x = x+1; x = x-1*/
 - Anweisungen der formavariabile=variable operator ausdruck; sie können wie folgt geschrieben werden:
variable operator=expression;

Bedingte Anweisungen

Relazionali: = =, !=, <, >, <=, >=

Logici: ! (not), || (or), && (and)

- Zyklen (alle Zyklen können miteinander verwoben werden)

If-Else-Zyklus

if (espressione) { /*Zyklus wenn-anders: wenn die Bedingung von if nicht ist

Ablauf der Anweisungen Wenn der Rechner zum andern übergeht; die Wenn-Klauseln können
}else { in der Serie gesetzt sein
Sequenz von Anweisungen

While-Schleife

while(Bedingung){ /*ciclo fintantoché: esegue le istruzioni fino a quando

Befehlsfolge Die Bedingung ist nicht mehr wahr

do-while-Schleife

tun { /*ciclo fai-finoa: fa continuamente le stesse azioni

Anweisungspfad bis die Bedingung wahr ist*/
} während (Bedingung);

For-Schleife

für (1.exp.Iniz; 2.Bedingung; 3.exp.Incr) { /*Schleife für: von Ausdruck 1, führe Anweisungen aus, führe aus
Anweisungsfolge Ausdruck 3, bis zu welcher Bedingung ist er wahr */
}

Switch-Case-Zyklus

switch ( var ) {
fallv1:ist.1; brechen; /*beachte Variable, Fall 1 usw., wenn ein Fall verobreakserve ist

fall...:ist.2; brechen; um die folgenden Fälle nicht zu überprüfen, wird standardmäßig immer
casevi: kontrolliert
casevj:ist.ij; break;
Fall...: ist.3; brechen;
casevN:ist.N; break;
standard:ist.U; break;
}

continue; break; /*bei einer Bedingung, dann fortfahren; schleife beenden*/

gotoistruzione; /*wenn die Bedingung wahr ist, springt sie und geht zur angegebenen Anweisung*/

-Array(Folgen von in Folge angeordneten Elementen, Zahlen oder Zeichen)

Array: Zahlenfolgen

int/charnome.array[numero.elementi]; /*Deklaration Array*/

nome.array[n] Die Position eines Elements wird durch den Index n angegeben, der von 0 (erster
elemento) anumero.elementi-1(ultimo elemento)*/

Die MAX_LUNG des Arrays kann in einem #define deklariert werden, aber die tatsächliche Länge wird zur Laufzeit entschieden.
die Ausfüllung über:

-sentinella: Mit einer while-Schleife, bis der Benutzer einen bestimmten Wert eingibt, wird das Array weiterhin fortgesetzt.
sich mit Werten füllen. [z.B.: während(temp!=-1 && i<MAX_LUNG)]
Lassen Sie einen Wert für den Benutzer eingeben, der dann in die zweite Bedingung einer for-Schleife eingefügt wird.

Man kann nicht am gesamten Array arbeiten, sondern nur an seinen einzelnen Elementen; mit all den anderen Funktionen ist es, als ob
war ein Ganzes.

Strings

charnome.stringa[numero.elementi];
nome.stringa[n]

strcpy(str1, "alfa"); / Initialisiere str1 mit dem String "alfa"/ / str1 enthält "alfa"/

strcpy(str2, str1); / kopiere str1 in str2/ / str2 enthält "alfa"/

x = strlen(str1); / Länge von str1/ / x nehme den Wert 4 an /

printf("%s", str1); / schreibe str1 auf Standardausgabe/ / schreibe str1 auf stdout/

scanf("%s", str1); / Lese str1 von der Standardeingabe/ / empfange/

Struktur
strukturiert {
Deklarationen von Variablen oder Arrays oder Zeichenfolgen;
} Name Struktur;

Zuweisungen, Lesungen und Druck: (Regeln für Strings, Arrays und Variablen) nomestruct.namevariable

•Zuweisung zu den Feldern des Datensatzes:

strcpy(indirizzo.via, "Ponzio");
adresse.nummer 34;
Adresse.PLZ 20133;
strcpy(indirizzo.citta, "Mailand");
dato: struct{…}rec1,rec2; si può assegnare rec1 = rec2

•Zugriff (lesen, schreiben…):

printf("%d\n", indirizzo.numero);
34
printf("%d\n", strlen(indirizzo.citta));
6
printf("%s\n", indirizzo.citta);
Mailand
scanf("%s", indirizzo.via);
Ponzio
scanf("%d", &indirizzo.CAP);
20133

Definition von Typen

typedefstruct {
Definition von Variablen, Array von Zeichenfolgen;
} name.type;

Variablendeklaration: name.typname.variabel

- Zeiger
Typo /*die Deklaration eines Zeigers auf einen Typtyp; kann nur auf diesen zeigen
Typ*

&Variabile /*es zeigt die Adresse der Variable an;& ist der Operator, der die Adresse zurückgibt
eine Variable

p = &i; (Dereferenzierungsoperator)

Der gegenteilige Operator ist , das den angegebenen Wert zurückgibt

i =  p; (Dereferenzierungsoperator)

**p /*mit dem doppelten * ist ein Zeiger auf einen Zeiger gemeint*/

NULL /*Anfangswert eines Zeigers, zeigt auf nichts*/

Zugriff auf Strukturfelder mit Zeiger:

p name.field 12;
(p).nome.campo 12;

sizeof() /*gibt die Anzahl der von einer Variablen oder einem Typ belegten Bytes zurück*/

Spiazzamento negli array:

Wenn zwei Zeiger auf zwei Elemente eines Arrays zeigen, gibt ihre Differenz den Abstand im Array an.
nicht die arithmetische Differenz

- Funktionen (Unterprogramme)

<returned type><function name>(<list of arguments>) {

<variabililocali>
<corpodella funzione>
<returnnome.variabile>}
Eine Funktion muss zu Beginn des Programms vor der int main() deklariert werden; die Definition muss geschrieben werden bei
gut.

tiponome(Themen) {
erklärungvariablenlokal
Anweisungen;
returnvalore.o.espressione;
}
Zuweisung des Wertes, der von der Funktion zurückgegeben wird:

variabile = name.function(arguments)

-Rückführungen

tiponome.Funktion (Argumente) {
wenn(Bedingung)

return 1;
sonst
return n *nome.funzione(argumente); /*Operation, die die Funktion selbst aufruft*/
}
Bemerkenswerte Unterprogramme

Umwandlung in Binär

/* berechnet die Umwandlung des Exponenten in binär */

num = esp;
for(ind = DIM-1; ind >= 0; ind--) { /* mit einem Index von DIM-1 bis 0 */
binario[ind] = num % 2; /* berechne ein neues Bit */
num /= 2; /* aktualisiere num für den nächsten Zyklus */
}
/* zeigt den binären Vektor an */
Umwandlung der Zahl %d:

für (ind = 0; ind < DIM; ind++) /* Zeigt den Binärvektor an: */
printf ("%d",binario[ind]); /* ein Bit nach dem anderen */