Sie sind auf Seite 1von 8

1. Prüfung:

Schwerpunkte:

Elementare Datentypen Formatierte Ein/Ausgabe mit prinf/scanf Verzweigungen (if-else)

2.Prüfung:

Schwerpunkte:

Ausdrücke Funktionen, Module, Gültigkeitsbereich, Lebensdauer Felder (Arrays) und zusammengesetzte Datendypen Zeiger

Befehle:

GCC Befehle:

#/bin/bash

# preprocessor

gcc -E hello_world.c -o hello_world.i

# preprocessor + compiler

gcc -S hello_world.c -o hello_world.s

# preprocessor + compiler + assembler

gcc -c hello_world.c -o hello_world.o

# preprocessor + compiler + assembler + linker

gcc hello_world.c -o hello_world

Studio und main():

#include <iostream> Input Output Data #include <ctype.h> // isdigit()

#include <math.h>

#include <stdio.h> // printf() #include <stdlib.h> // EXIT_FAILURE, EXIT_SUCCESS #include <string.h> // strlen()

// pow()

int main() {

IF-Anweisung:

if (Bedingung 1)

{

Anweisungsblock 1

}

else if (Bedingung 2)

{

Anweisungsblock 2

}

else

{

Anweisungsblock 3

}

Switch

switch(‘Ausdruck als ganzzahliger Wert’) case 1

{

optional: break verlässt switch Block

}

case 2

case 3

{

mehrere Auswahlwerte können die gleiche Anweisung auslösen

}

default wird genommen, wenn kein break oder case erfüllt

While-Schleife:

while (Bedingung)

{

Anweisungsblock;

}

Do-While Schleife:

do

Anweisung/Block

while (‘Bedingung’);

For-Schleife:

for (Initialisierung, Bedingung, Zähleranpassung)

{

Anweisungsblock;

}

Schleifenabbruch/Fortsetzung:

In einer for/while/do while Schleife mit ‘break’ ans Schleifenende, mit ‘continue’ an den Schleifenanfang springen.

Operatoren:

Auswertung von rechts nach links.

springen. Operatoren: Auswertung von rechts nach links. sizeof(t) Speicherbedarf für Datentyp t sizeof a

sizeof(t)

Speicherbedarf für Datentyp t

sizeof a Speicherbedarf für Ausdruck a

a , b

Erst Auswertung von a, dann auswertung von b

a = (b>0) ? 1 : 2;

Bedingter Ausdruck: wenn b>0 ist a = 1, sonst = 0

Zusammengesetzte Operatoren:

a += b => a = a+b

Typumwandlung

Wandlung->Gleitpunktzahl in "longint", dann Nachkommastellen abschneiden.

inta = (int) 3.14; a=3

Ganzzahl->Ganzzahl Bei Wandlung in kleineres Speicherformat werden die höherwertigen Bits abgeschnitten.

chara = (char) 0xAFF4; a=F4

mit VZ->ohne VZ (vgl. 2erKomplement) Wandlung mit VZ, dann Interpretation des Bitmuster ohne VZ.

unsignedchara = (unsignedchar) -12; a=244

Gleitpunktzahl->Gleitpunktzahl Liegt Zahl außerhalb des darstellbaren Zahlenbereichs, erfolgt Fehlermeldung und Abbruch, ansonsten wird gerundet.

floatf = (float) 3.14159265359; f=3.1415927

Varianten des Speicherzugriffs:

&a Ergebnis ist die Adresse von a

*a Ergebnis ist der Wert des Datenobjektes an der Adresse

aa[x] Ergebnis ist das (x+1).Element des Feldes aa.

b Ergebnis ist der Wert des Elements b in der Struktur

aa ->b Ergebnis ist der Wert des Elements b in der Struktur,die durch a adressiert wird

Print/Scan:

scanf("%d", &alter);

f=floating point

d=ganze Zahl Dezimal x=ganze Zahl Hexadeziaml c=Einzelzeichen *=Keine Zuweisung durchführen 1=Statt int long verarbeiten printf("Text %06.4f”, 1,23, arg2, f=floating point d=ganze Zahl Dezimal x=ganze Zahl Hexadeziaml c=Einzelzeichen s=String 0=mit Nullen auffüllen 6.4=6 Zeichen vor Komma (Breite), 4 danach (Genauigkeit)

)

Switch

int age = 42; switch (age) {

case 16:

cout << "Too young";

break;

case 42:

cout << "Adult";

break;

Formatierung:

printf(“

%06d

Mit Nullen auffüllen 6 Ziffern lang

printf(“

%8.4f

8 Ziffern lang 4 Nachkommastellen

String:

char string[] = “die chönsten Dinge….”; generiert String

printf(“Denke daran, %s\n”, *(string+4); Ausgabe fünftes Zeichen

printf(“erstes Zeichen %c\n”, string[0]) Gibt das erste Zeichen des string aus int strlen(string) gibt Länge aus char * strcpy(char * dest, char *src) Kopiert Zeichenkette src nach dest char * strcat(char *dest, char *src) Hängt src an dest an int strcmp(char *str1, char *str2) Vergleicht lexikalisch String str1 und str2, Rückgabe -1,0,1

Kontrollstrukturen:

Felder int z[6] Array mit 6 Integer Elementen, beginnend bei z[0]! float [4] = {2.4,

Felder

int z[6] Array mit 6 Integer Elementen, beginnend bei z[0]! float [4] = {2.4, 3.6, 3.87, 2.9} Direkte Zuweisung der Elemente int z[2][3] = {{2,4,3},{4,7,6}} 2x3 Matrix Array

Character Arrays

char text1[] = Studium Jedes Zeichen ein Arrayfeld, Ende wird mit \0 gekennzeichnet.

Zusammengesetzte Datentypen (Struktur)

struct Anschrift

{

int Alter

}

char Name [30]

struct Anschrift Schüler Schüler ist Variable für Struktur Anschrift Schüler.Alter = 15

Zugriff auf einzelne Elemente per . Operator

Zeiger

int x = &p Adressoperator: Liefert Adresse der Variable p int x, *p

Inhaltsoperator: Deklaration von p als Zeiger auf int

x = *p

Inhaltsoperator: x wird Wert zugewiesen, der an der Adresse von p gespiechert ist

Addition:

p = q + i

i hat Typ t, dann ist p ist Adresse q + i mal Speicherbedarf von t

Zeiger als Schleifen Laufvariable:

int Feld [] = {5, 3, 6} for (p = Feld, *p != 6, p++) printf (“%d, “*p); Ausgabe: 5, 3

Konstante Zeiger:

const int *konstantesZiel = &ZielVariable const vor Typ: Zielvariable darf nicht verändert werden int * const konstanterZeiger = &ZielVariable const vor Name: Ziel des Zeigers darf nicht geändert werden, Inhalt schon const int * const komplettKonstant = &Zielvariable nichts darf verändert werden

Zeiger auf Strukturen:

struct messwert feld [100]; struct messwert *ptr; ptr = feld; Speichervariable deklarieren

(*ptr).nummer = i; ptr -> nummer = i; Zugriff: Bedeutet das selbe, unten kurz Schreibweise

Zeiger auf Zeiger:

struct messwert **ptrptr; Zeiger auf Zeiger (**ptrptr).nummer = i; *ptrptr -> wert = -1.0

2D Felder:

Zeiger auf Funktionen:

void (*f)()

f ist Zeiger auf Funktion ohne Parameter&Rückgabewert int (*f) (int);

f = up1

Adresszuweisung

f() up1 wird über f aufgerufen

Array von Funktionen:

vorher drei Funktionen mit selbem Prototyp initialisiert:

int add(int a, int b)

int (*math[]) (int, int) = {add, mul, sub}; int auswahl;

ergebnis = math[auswahl] (wert 1, wert 2);