Motivation

Effizient

• C erlaubt es, sehr effizienten Code zu schreiben.
• Der verbraucht Arbeitsspeicher (Memory Footprint) ist sehr leicht.
• Die Ausführungsgeschwindigkeit ist hoch, weil Optimierungen zur Compilezeit ausgeführt werden.

Verbreitet

• C/C++ ist mit grossem Abstand die wichtigste System- und systemnahe Sprache

Systemverständnis

• C fördert und bedingt das Verständnis für das unterliegende System

Hauptprgrogramm

#include <stdio.h>    //printf
#include <stdlib.h>

int main (void)
{
	printf("Hello world in C\n"); // Newline ist wichtig
	return EXIT_SUCCESS;
}

Datentypen

Standard Typen

Integer

#include <stdint.h>

int8_t signedValue;
uint8_t unsignedValue;

int16_t signedValue;
uint16_t unsignedValue;

int32_t signedValue;
uint32_t unsignedValue;

int64_t signedValue;
uint64_t unsignedValue;

Bool

#include <stdbool.h>

bool trueValue = true;
bool falseValue = false;

Literalle / Konstanten

• Im Code eingefügte, unveränderliche Werte
• Ist die Zahlt zu gross für int, wird diese als long interpretiert.

int decimal = 3987; // beginnt mit 1 - 9

unsigned int octal = 037;  // starts with 0

unsigned int hexadecimal = 0x23; // starts with 0X or 0x

char asciiCode = 'A'; // single ascii code 

double decimalPoint = 1.23;

double exponent = 1.6e3;

Explizite Angabe

int interpretedAsLong = 134L;

int interpretedAsLongLong = 134LL;

// U kann alleine, oder zusätzlich zu L / LL hinzufgefügt werden.
int interpretedAsUnsigned = 134U;

float interpretedAsFloat = 1.23F; // f geht auch

double interpretedAsDouble = 1.23L; // Long float

Zeichenliterale

Ascii Tabelle

Strings

Durch Anführungszeichen eingeschlossene Zeichenfolgen werden als strings interpretiert.

char[] iAmString = "Hello World!";

Symbolische Konstanten

Symbolische Konstanten werden Textmässig ersetzt.

#define MAX_LENGTH 1000

Anwendung

#define MAX_LENGTH 1000

int length = MAX_LENGTH; // MAX_LENGTH wird durch den Wert im define ersetzt

Definitionen

• Sind Variablen ausserhalb von Funktionen definiert, sind diese lokal in der Source (.c) Datei.

Variablen

Eine Variable sollte immer auf einen Wert initialisiert werden, da es keine Standardwerte gibt.

double hoehe;
int laenge, breite; // mach das nicht
double r,
	radius = 15.0;  // Besser so, dann ist es klar, dass nur radius auf 15.0 ist

Konstanten

Konstanten sind nicht veränderlich.

const double pi = 3.14159;

Typ Alias

Erlaubt es eigene Typen zu definieren, oder auch Synonyme.

typedef int Index; // sagt, dass Index von typ int ist.

Index index = 0; // Index kann jetzt als Typ verwendet werden

typedef struct position
{
	int x;
	int y;
} Position;

Position position;
position.x = 1;
position.y = 2;

Statisch

Statische Variablen sind prozessübergreifend.

static int value;

• Wenn im Header definiert, dann sind diese sobald diese inkludiert wird, verfügbar.
• Wenn in der Source Datei definiert, dann sind diese in der gleichen Datei in allen Prozessen verfügbar.

Bit-Operatoren

Vorrang und Reihenfolge

Type Casts

Ein type cast wird benötigt, um ein typ explizit in einen anderen Typen zu wandeln

int value = 5;
int divider = 3;
double result = (double) value / divider;

Kontrollstrukturen

If-Else / Else-if

const int SOME_CONSTANT = 10;
int value = 5;
if (value > SOME_CONSTANT) {
	// Do something if greater than SOME_CONSTANT
} else if (value < SOME_CONSTANT) {
	// Do something if less than SOME_CONSTANT
} else {
	// Do something if equal to SOME_CONSTANT
}

For-Schleife

for (int i=1; i <= 5; i++) {
	// Mache etwas in der for schleif
}

While

Zuerst wird die Bedingung geprüft, dann der Inhalt der Schleife ausgeführt

int i=0; // Initialisierung its wichtig
while (i < 5)
{
	// Mache etwas in der for schleife
	i++; // i muss manuell verändert werden
}

Do while

Im Gegensatz zur While schleife, wird in der Do-While der Inhalt der Schleife zuerst ausgeführt.

int i=0; // Initialisierung its wichtig
do
{
	// Mache etwas in der for schleife
	i++; // i muss manuell verändert werden
	// WIRD MINDESTENS 1 MAL AUSGEFÜHRT
}
while (i < 5);

Switch

Es können keine Strings evaluiert werden!!

int n;
switch (n)
{
case 1:
{
	// Wenn 1
	break;
}
case 2:
case 3:
{
	// Wenn 2 oder 3
	break;
}
default:
{
	// Alles andere
	break;
}

}

Input

stdout / stdin / stderr sind auf der Konsole

Konstanten String auf StdOut ausgeben

#include <stdio.h>

int result = puts("Hello world");
if (result == EOF) 
{
	// Konnte nicht geschrieben werden
}

Einzelnes Zeichen auf StdOut ausgeben

#include <stdio.h>

int result = putchar('A');
if (result == EOF) 
{
	// Konnte nicht geschrieben werden
}

Einzelnes Zeichen von StdIn lesen

#include <stdio.h>

char c = getchar();

// Das Zeichen wird in c gespeichert

Formatierte Ausgabe / Eingabe

#include <stdio.h>

printf(format, arg1, arg2, . . .); // für Ausgabe

scanf(format, &x, &y, &z); // Parameter (ausser string (char*)) mit & angeben

Der Parameter format ist ein String. Jedes der zusätzlichen Argumente (arg1, arg2, …) ist in diesem Forhanden und kann folgedes bedeuten.

Formatierung von Float

%m.df

#include <stdio.h>
double value = 5.12345;

printf("%f", value); //5.123450 (dezimal standard=6)

printf("%.3f", value); //5.123

printf("%10.3f", value); //      5.123 (6 Leerzeichen)

Enums

enum Wochentage
{
	Monday,  // int wert ist 0
	Tuesday, // int wert ist 1, nachfolgende sind vortlaufend
	Wednesday,
	Thursday = 13, // int wert ist 13 
	Friday, // int wert ist 14
	Saturday,
	Sunday
};

// Direkt auf Monday zugreifen, keine Angabe des Namespaces notwendig
Wochentag tag = Monday;


int dayOfWeek = tag; // 

Strukturen / Datenklassen

struct Point3D
{
	double x;
	double y;
	double z;
}

struct Point3D ptA = {1.0, 3.0, 4.0}; // Standard initialisierung

ptA.x = 5.0; // Zugriff

Mit Typedef

typedef struct
{
	double x;
	double y;
	double z;
} Point3D;

Point3D ptA = {1.0, 3.0, 4.0}; // Standard initialisierung

ptA.x = 5.0; // Zugriff