Summary

C Referenz

1.902 Words / ~15 pages
<
>
swopdoc logo
Download
a) trade for free
b) buy for 1.41 $
Document category

Summary
Information Technology / Computer S

University, School

Fachhochschule Kempten - FH

Author / Copyright
Text by Hedwig . ©
Format: PDF
Size: 0.67 Mb
Without copy protection
Rating [details]

Rating 4.2 of 5.0 (12)
Live Chat
Chat Room
Networking:
0/0|0[-3.0]|1/4







More documents
Leerverkäufe Short-Sales Inhaltsverzeich­nis Abbildungsverze­ich­nis. - 1 - 1 Einleitung. - 2 - 2 Grundlagen. - 3 - 2.1 Begriffsabgrenz­ung Leerverkauf und der Vergleich zum Aktienkauf. - 3 - 2.2 Gedeckter Leerverkauf vs. Ungedeckter Leerverkauf. - 5 - 2.3 Alternative Leerverkaufsins­tru­mente. - 8 - 3 Investmentstrat­egi­en/Motiv­e für den Leerverkauf. - 10 - 3.1 Der Leerverkauf als Spekulationsins­tru­ment - 10 - 3.2 Absichern von existierenden Positionen (Hedging) - 10 - 3.3 Nutzen von Arbitragemöglic­hk­eiten…
In dieser Rolle kehrt er zu Kristeller zurück, um den Pakt mit Kristeller einzulösen und sich sein Vermögen und noch mehr, das Rezept des Kristeller Likörs zu holen. Fazit Werden nun die beiden Bezugsquellen gegenübergestel­lt­, stellt sich der historische Bezug zu Wilhelm Raabes „Zum Wilden Mann“ schwerer dar. Florian Krobb argumentiert stark an der Person Aloys von Schäffer, die wohl einen sehr starken Einfluß im 19. Jahrhundert hatte und auch prägend gewesen sein mag. Allerdings erschließen sich mir nicht ganz die Details,…

C Referenz

1. Datentypen, Operatoren und Ausdrücke. 2

a. Low-Byte / High-Byte. 2

b. typedef. 2

c. Konstanten. 2

d. Aufzählungskonstanten. 2

e. Variablenvereinbarung. 2

f. Typkonvertierungen. 3

i. Implizite Typkonvertierung. 3

ii. Explizite Typkonvertierung. 4

g. Arithmetische Operatoren. 4

h. Vergleichsoperatoren. 4

i. Zuweisungsoperatoren. 4

j. Logische Operatoren. 4

k. Operatoren zu Bit- Manipulation. 5

l. Sonstige Operatoren. 5

2. Ein- und Ausgabe. 5

a. Funktion scanf. 5

b. Funktion printf. 5

3. Kontrollstrukturen. 6

a. if - / if – else – Anweisung. 6

b. 4.2 switch-Anweisung. 6

c. for-Anweisung: 6

d. while- und do-Anweisung. 7

e. continue- und break-Anweisung. 7

4. Funktionen. 8

a. Funktionsdeklaration und Funktionsdefinition. 8

b. Übergabe von Argumenten und Rückgabewerten. 8

c. Gültigkeitsbereich und Lebensdauer von Variablen. 9

5. Pointers und Vektoren. 10

a. Pointers. 10

b. Argument – Übergabe an Funktionen. 11

c. Vektoren. 11

d. Zusammenhang zwischen Pointer und Vektor. 11

e. Pointer-Arithmetik. 12

6. Strukturen Datentypen. 13

7. Unions. 14

a. Bit-Felder. 14


1.     Datentypen, Operatoren und Ausdrücke

a.     Low-Byte / High-Byte

Speicherplatz im Arbeitsspeicher zB. 0x12345678
Little endian byte ordering: low-byte=12 & high-byte=78
Big endian byte ordering: low-byte=78 & high-byte=12

b.     typedef

type_def.h

/*** Definition of global types ***/
typedef unsigned char U_INT8;


programm.c

#include >type_def.h>
main()
{
U_INT8 variable1, …, variablen;
}

c.      Konstanten

84U à unsigned int 84
84 L
à long ing 84
84 UL
à unsigned long int 84
1.475e-3F
à float
‛A’
à vom typ int (Wert anhand der ASCII Tabelle)
printf(“\”abc\””);
à //“abc”

d.     Aufzählungskonstanten

typedef enum {OFF, ON} KEY; // OFF=0 und ON=1

e.     Variablenvereinbarung

#define MAX_VAL 300 // präprozessoranweisung
const unsigned char test=2; //Wert nach initialisierung nicht änderbar
volatile unsigned char test=2; // variable bleibt unbeachtet in Compileroptimierung


f.       Typkonvertierungen

-bei Verknüpfung von Operanden mit unterschiedlichem Datentyp, ist Datentyp-Umwandlung erforderlich.

                                  i.      Implizite Typkonvertierung

Compiler nimmt automatisch Typkonvertierung vor.

o   für einen Ausdruck gilt u.a.:

- ist ein Operand long double, werden andere Operanden in long double konvertiert

Hierachie - ist ein Operand double, werden andere Operanden in double konvertiert

Free of charge
Download
C Referenz
Click on download to get complete and readable text
• This is a free of charge document sharing network
Upload a document and get this one for free
• No registration necessary, gratis

- ist ein Operand float, werden andere Operanden in float konvertiert

- Operand vom Typ char u. short werden in int konvertiert

- ist ein Operand long, werden andere Operanden in long konvertiert

- ist ein Operand unsigned int, werden andere Operanden in undsigned int konvertiert

o   Beachte:

·         float-Op. Werden nicht automatisch in Typ double konvertiert

·         Zuweisungen: Wert auf rechter Seite wird in Typ linker Seite konvertiert


Ø  Integrer – Erweiterung

o   Konvertierung char, short int in int, wenn int zur Wertaufnahme ausreicht, sonst in unsigned int

o   C definiert nicht, ob char- Variable Vorzeichen besitzen à Konvertierung char-Variable in int-Variable maschinenabhängig z.B.:

char val1 = 0x84;
short int val3;
val3 = val1; // val3=0x0084 oder val3=0xFF84

o   eindeutige int-Konvert.:

unsigned char val1 = 0x84;
signed char val2 = 0x84;
short int val3;
val3=val1; // val3=0x0084
val3=val2; // val3=0xFF84


                                ii.      Explizite Typkonvertierung

o   Anweisung Typumwandlung eines Ausdrucks mittels cast-Operator:
(type_name) expression

o   Typumwandlung des Wertes von eypression in Typ type_name entsprechender Typkonvertierungsregeln z.B.:
Bibliotheksfkt. sqrt ( n ) mit n vom Typ double
#include <math.h>
unsigned int m_val;
double result;
result = sqrt ((double) m_val);

o   bei Zugriff auf Absolutadressen ist expl. Typkonvertierung erforderlich

o   Beachte:
-int-Werte mit „gr. Bereich“ werden in int-Werte mit „kl. Bereich“ konvertiert, durch Abschneiden überzähliger Bits von links her
-bei Typumwandlung float in int wird Bruchteil abgeschnitten
- Typkonvertierung double in float ist implementationsabhängig.


g.      Arithmetische Operatoren

% Modulo-Division // 8 % 3 à =2

o   Bei division von int-Werten wird gebrochener teil Abgeschnitten

o   Auf float- u.- double-Werten %-Op, nicht anwendbar

h.     Vergleichsoperatoren

o   numer. Wert vergleichsoperation:
1: Vergleich trifft zu (true)
0: Vergleich trifft nicht zu (false)

i.        Zuweisungsoperatoren

o   expr2 op = expr2 // Äquival.: expr1 = (expr1) op (expr2)

j.        Logische Operatoren

o   && log. UND

o   || log. ODER

o   ! log. Negation
Negationsoperator ! besitzt Wert:
1 wenn Operand = 0
0 wenn Operand ≠ 0
Test auf ungleich 0 à If (x) statt if (x!= 0)
Test auf 0 à If (!x) statt if (x== 0)
if((val1>val2)&&(val3++<val4)) à gefährlich!
Auswertung von links nach rechts, abgebrochen, sobald Resultat feststeht !!!

k.      Operatoren zu Bit- Manipulation

o   Bit-.Operatoren:
& UND
| ODER
^ Exklusiv – ODER
<< Shift left inbyte <<=0x03 à 3 NULL-Bits von rechts
>> Shift right outbyte >>=0x03 à 3 NULL Bits von links (unsigned)
à Vorzeichen Bit oder NULL Bit bei (signed)
~ Bit – Komplement

o   konditionaler Operator ?:
- Max_temp=(temp1>temp2) ? temp1:temp2;
expr1 ≠ 0: condition true à Berechnung expr2
expr1 = 0: condition false à Berechnung expr3
àResultatwert ist Wert des ermitt. Ausdrucks

o   Operator sizeof
length=sizeof array;
length=sizeof(long double);
à liefert Anzahl an Bytes zur Speicherung

2.     Ein- und Ausgabe

scanf Lesen von Zeichen aus Standard-Eingabe

fscanf Lesen von Zeichen aus einer Datei

getchar Lesen eines Zeichens aus Standard-Eingabe

printf Ausgabe von Zeichen auf Standard-Ausgabe

fprintf Ausgabe von Zeichen in Datei

putchar Ausgabe eines Zeichens auf Standard-Ausgabe

Voraussetzung für Verwendung E/A-Funktionen: #include <stdio.h>

a.      Funktion scanf

Scanf(“formatangaben“ , &arg1 , &arg2,…);

Scanf(“%d %f %c %x”, &wert, &var, &zei, &addr); à %d gehört zu &wert, %c gehört zu &zei …

b.     Funktion printf

Printf(“formatangaben“, arg1, arg2, …);Ausgabe Text u. Daten:

z.B.: printf(“Spannung u1: %fV“, u_1);


3.     Kontrollstrukturen

a.      if - / if – else – Anweisung

o   allg. Form:

if (expression)
{
statement_1;
next_statement;
}

else
statement_2;

o   ohne {} immer nur für einen Anweisungsblock gültig

b.     4.2 switch-Anweisung

o   allg. Form

o   es gilt
-Wert von expression: int-Typ
-const_i: ganzz. Konstante, konst. Ausdruck
-default ist optional
-mehrere case-Konstanten vor einem statement
-switch-Anw. können verschachtelt werden
-break; Verlassen switch-Anweisung

c.      for-Anweisung:

o   allg. Form:

for(expr1; expr2; expr3;)
{
statements;

}

expr1 einmal bewertet
expr2 vor jeder Wiederholung berechnet:
-Wert ungleich Null (true); à Ausführung statement
-Wert gleich Null (false): à Beenden for-Anw.
-expr3 nach jeder Wiederholung bewertet

d.     while- und do-Anweisung

o   allg. Form:

while (expression)
{
statements;
}

do

{
statements;
}
while (expression);

o   statement wird solange ausgeführt, solange Wert von expression ungleich Null (true)

Ø  continue

o   beendet innerhalb for-, while-, do-Anw. akt. Schleifendurchlauf u. verzweigt zum nächsten Durchlauf

o   allg. Form:

continue;

Ø  break

o   beendet for-, while-, do-, switch-Anw. vorzeitig u. verzweigt zu next_statement

o   -allg. Form:

break;


4.     Funktionen

a.      Funktionsdeklaration und Funktionsdefinition

o   allg. Form:
Typ Rückgabewert (optional) à void ohne return value
Typ u. Parametername (optional) à void ohne parameter

o   Beispiel: Aufbau C-Programm:

#include < . . . >
#define . . .
/* Funktionsdekl. */
void int_ports (void);
unsigned short int read_sensors (char val1, char val2, unsigned char3);

/* Funktion main */
void main(void)
{

char count1, count2;
unsigned char count3;
unsigned short int act_pos;

act_pos = read_sensors (count1, count2, count3); /* Funktionsaufruf /*
act_pos = int_ports ();
}

/* Funktionsdef. */

void int_ports (void)
{
Anweisungen
}
unsigned short int read_sensors (char val1, char val2, unsigned char val3)
{
Anweisungen
}

o   Call by value:
Argument-Übergabe erfolgt als Wert

o   Return-Anweisung:
return (expression); à return (variable);
Rückgabe Wert von expression an aufrufende Funktion.

o   - ggf. Typkonvert. in Resultattyp Fkt.
- fehlt expression: Rückkehr ohne return value
- aufrufende Fkt. kann return value ignorieren
- jede Fkt. besitzt max. eine return-Anweisung
- aufgerufene Fkt. erhällt nicht ursprüngliche Argumente, sondern lokale Kopien

c.      Gültigkeitsbereich und Lebensdauer von Variablen

o   lokale Variable:
- wird nach Blockanfang def. und gilt bis Blockende
- aktueller Wert geht von einem Funktionsaufruf zum nächsten verloren

o   globale Variable: à z.B.: unsigend short int global_control;
- wird außerhalb aller Funktionen eines Moduls def.
- gilt bis zum Modul-Ende
- akt. Wert bleibt bis zur nächsten Zuweisung erhalten

extern void read_frequ(void);
extern unsigned char counter;
double max_frequ = 0;
void main(void)
{

read_frequ();

if ( max_frequ >= …)

if (counter == …)

}

Modul 2

extern double max_frequ;
unsigned char counter = 1;
void read_frequ(void)
{

max_frequ = …
counter = …

}

o   Static-Variable u. static-Funktion:
- Gültigkeitsbereich auf Block beschränkt, in dem Variable def. wurde
- Lebensdauer bleibt über gesamten Programmablauf erhalten

void write_lcd (…)
{
static unsigned short int cursor_pos = 0;

cursor_pos = …

}

o   Static globale Variable u. Funktion:
- Gültigkeitsbereich auf Modul beschränkt, in dem Variable bzw. Funktion def. wurde
- Lebensdauer von Variablen bleiben über gesamten Programmablauf erhalten
- wird außerhalb der Funktion deklariert

a.      Pointers

o   unsigned char *byte_ptr;
- Pointer zeigt nur auf den in Def. festgelegten Datentyp

o   Adress-Operator: &

float &act_temp ; // erste Adresse der float variable wird angezeigt
(float 4 bytes groß)

unsigned &char out_byte; // Adresse der char variable wird angezeigt

liefert in Verbindung mit einem Variablennamen die Adresse der Variablen

o   inhalts-Operator: *
liefert angewandt auf einen Pointer, das Objekt auf das der Pointer zeigt (Wert der Variable wird angezeigt, auf die der Pointer zeigt)

*byte_ptr; // initialisierung des pointers byte_ptr (4 bytes groß)
unsigned char byte1 = 21; // initialisierung der variable byte1
byte_ptr = &byte1; // Adresse von byte1 wird in byte_ptr geschrieben
byte_ptr*; // Inhalt von Variable byte1 wird angezeigt


o   Call by reference

void swap (unsigned char *byte_p1, unsigned char *byte_p2);
main()
{
unsigned char high_byte, low_byte;
swap (&high_byte, &low_byte); /*byte swap*/
}
void swap (unsigned char *byte_p1, unsigned char *byte_p2)
{
unsigned char temp;
temp = *byte_p1;
*byte_p1 = *byte_p2;
*byte_p2 = temp;
}

- korrekter Tausch von high_byte, low_byte in main
-wird Name eines Vektors als Argument an Fkt. übergeben, erhält Fkt. Adresse des Vektors

c.      Vektoren

o   allg. Form: à typ vektor_name [elemente_anzahl];

unsigned char buffer[40]; //Vektor besitzt 40 Elemente buffer[0]-buffer[39]
unsigned char message [] = “HELLO“; // Vektor besitzt länge 5
double temp[400] = {10.0, 20.0}; // rest wird mit NULL aufgefüllt
unsigned char *message_p = “hello tom“; // Pointer zeigt auf die Adresse des Strings mit dem Inhalt “Hello Tom“
*(message_p+7) = ‛i‛; // *(&message[7]) = i;
unsigned int position[3][2] = {{3,2},{5,7},{6,3}}; // 2 Spalten, 3 Zeilen
out_ptr=error_p[2]

buff_ptr=&buffer[0]; // 1 Adresse vom Vektor buffer wird in buff_ptr geschrieben
buff_ptr=&buffer[3]; // 4 Adresse vom Vektor buffer wird in buff_ptr geschrieben
buff_ptr=buffer;
buff_ptr=buffer+3; // gleicher aber besserer code als oben
value=buffer[3]; // Inhalt vom Vektor buffer wird in value geschrieben
value=*(buffer+3); // gleicher code (erst Klammer dann Inhaltsoperator)


e.     Pointer-Arithmetik

a) Zuweisung auf Pointer

-Pinter kann mit Pointer gleichen Typs oder mit ganzz. Ausdruck initial. warden

unsigned char *count_p1, **count_pp; //** Pointer der auf Pointer zeigt
port1_p = (unsigned char *) 0x00F00000;
count_pp = &count_p1; //count_pp erhält Adresse auf die count_p1 zeigt
++**count_pp; // ++(*(*count_pp))

-zu Pointer kann int-Wert addiert/subtrahiert werden

number = *++rec_p; //Adresse um 1 erhöht und dann Wert zugewiesen
number = *(rec_p+2); // Adresse um 2 erhöht und dann Wert zugewiesen

c.) Subtraktion von Pointers

-Pointers können voneinander subtrahiert werden, wenn sie auf Elemtente des gleichen Vektors zeigen.

unsigend short int buffer[1000], *start_p, *end_p;
start_p = buffer; //Adresse von buffer wird start_p zugewiesen
end_p = buffer; //Adresse von buffer wird end_p zugewiesen
length = end_p – start_p + 1;

d.) Vergleich von Pointers

-Pointers können miteinander verglichen warden, wenn sie auf Elemtente des gleichen Vektors zeigen

unsigend short int i, j, *start_p, *end_p, out_buff[2000];
start_p = out_buff + i;
end_p = out_buff + j;
if (start_p > end_p )
{ /*error handling */ }


o   Struktur: Zusammenfassung von Variablen unterscheidl. oder gleichen Typs unter gemeinsamen. Namen

typdef struct
{
unsigend char day;
unsigend char info [3];
} MESSAGE_STRUCT;

MESSAGE_STRUCT short_message;
short_message.day = 5;
short_message.info[ 0 ] = `M`;

//oder
MESSAGE_STRUCT short_message = {20, “abc”};

o   - Struktur kann andere Struktur als Komponente enthalten

typedef struct
{
MESSAGE_STRUCT time;
float startTemp;
float endTemp;
} TEMP_MEAS;

TEMP_MEAS motorTemp;
meas_hour = motorTemp.time.day;

o   Vektoren von Strukturen

typedef struct
{
unsigned short int nr;
unsigned char art[4];
} MESS_STRUCT;

MESS_STRUCT messung[20];

o   Struktur kann anderer Struktur zugewiesen werden, wenn diese vom Gleichen Typ ist


Legal info - Data privacy - Contact - Terms-Authors - Terms-Customers -
Swap+your+documents