C-Kurs 2010 Pointer. 16. September v2.7.3
|
|
|
- Markus Berg
- vor 6 Jahren
- Abrufe
Transkript
1 C-Kurs 2010 Pointer 16. September 2010 v2.7.3 This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 License.
2 C-Kurs Mi Konzepte, Syntax,... printf, scanf Next Do Pointer, Arrays,... Compiler, Headers,... Fr Structs, malloc,... Debugging I,... + Vorstellung der Aufgabe Mo Di Lösung der Aufgabe Debugging II stdlib, Bücher,... 2
3 Ohne Pointer geht nichts. 3
4 Themen Hello Pointer Call by Reference NULL-Pointer Pointer auf Pointer Von Pointern zu Arrays Pointer-Arithmetik Strings und Längenberechnung Const Correctness Initialisierung von Strings Mehrdimensionale Arrays Programm-Argumente: argc und argv Weiterführende Themen Zusammenfassung 4
5 Pointer
6 Variablen im RAM 0 RAM 2³²-1 6
7 Variablen im RAM 0 RAM int i 2³²-1 7
8 Variablen im RAM 0 RAM int i 5 2³²-1 8
9 Variablen im RAM 0 RAM int i ³²-1 9
10 Variablen im RAM 0 RAM int i ³²-1 10
11 Variablen im RAM 0 RAM int i ³²-1 11
12 Variablen im RAM 0 RAM int i int * p ³²-1 12
13 Variablen im RAM 0 RAM int i int * p ³²-1 13
14 Variablen im RAM 0 RAM int i int * p ³²-1 14
15 Variablen im RAM 0 RAM int i int ** pp int * p ³²-1 15
16 Was ist ein Pointer? 16
17 Pointer kann meinen eine... A) B) 17
18 Pointer kann meinen eine... A) Adresse B) 18
19 Pointer kann meinen eine... A) Adresse B) Variable, die eine Adresse speichert 19
20 Hello Pointer
21 21 Hello Pointer #include <stdio.h> int main() { } return 0;
22 22 Hello Pointer #include <stdio.h> int main() { int i = 3; } return 0;
23 23 Hello Pointer #include <stdio.h> int main() { int i = 3; int * p = &i; } return 0;
24 24 Hello Pointer #include <stdio.h> int main() { int i = 3; int * p = &i; *p = 4; } return 0;
25 25 Hello Pointer #include <stdio.h> int main() { int i = 3; int * p = &i; *p = 4; p = 5; } return 0;
26 26 Hello Pointer #include <stdio.h> int main() { int i = 3; int * p = &i; printf(i == %d, p == %p\n, i, p); *p = 4; printf(i == %d, p == %p\n, i, p); p = 5; printf(i == %d, p == %p\n, i, p); } return 0;
27 27 Ausgabe # gcc hello_pointer.c -o hello_pointer
28 Ausgabe # gcc hello_pointer.c -o hello_pointer #./hello_pointer 28
29 Ausgabe # gcc hello_pointer.c -o hello_pointer #./hello_pointer i == 3, p == 0xbfa3ad8c 29
30 Ausgabe # gcc hello_pointer.c -o hello_pointer #./hello_pointer i == 3, p == 0xbfa3ad8c *p = 4; 30
31 Ausgabe # gcc hello_pointer.c -o hello_pointer #./hello_pointer i == 3, p == 0xbfa3ad8c *p = 4; i == 4, p == 0xbfa3ad8c 31
32 Ausgabe # gcc hello_pointer.c -o hello_pointer #./hello_pointer i == 3, p == 0xbfa3ad8c *p = 4; i == 4, p == 0xbfa3ad8c p = 5; 32
33 Ausgabe # gcc hello_pointer.c -o hello_pointer #./hello_pointer i == 3, p == 0xbfa3ad8c *p = 4; i == 4, p == 0xbfa3ad8c p = 5; i == 4, p == 0x5 33
34 34 Zusammenfassung 1/2 Operator & liefert eine Adresse
35 Zusammenfassung 1/2 Operator & liefert eine Adresse Operator * folgt einer Adresse (er dereferenziert) 35
36 Zusammenfassung 1/2 Operator & liefert eine Adresse Operator * folgt einer Adresse (er dereferenziert) & und * sind komplementär; es gilt: *(&x) = x 36
37 37 Zusammenfassung 2/2 Pointer zeigen auf typisierte Daten: int * char *
38 Call by Reference
39 Call by Reference #include <stdio.h> int main() { int i = 0; } return 0; 39
40 Call by Reference #include <stdio.h> int main() { int i = 0; by_value(i); } return 0; 40
41 Call by Reference #include <stdio.h> int main() { int i = 0; by_value(i); by_reference(&i); } return 0; 41
42 Call by Reference #include <stdio.h> void by_value (int x) { x += 3; } void by_reference(int * x) { *x += 4; } int main() { int i = 0; by_value(i); by_reference(&i); } return 0; 42
43 Call by Reference #include <stdio.h> void by_value (int x) { x += 3; } void by_reference(int * x) { *x += 4; } int main() { int i = 0; by_value(i); printf(i == %d\n, i); by_reference(&i); printf(i == %d\n, i); } return 0; 43
44 44 Ausgabe # gcc call_by_reference.c \ -o call_by_reference
45 Ausgabe # gcc call_by_reference.c \ -o call_by_reference #./call_by_reference 45
46 Ausgabe # gcc call_by_reference.c \ -o call_by_reference #./call_by_reference i == 0 i == 4 46
47 NULL-Pointer
48 NULL-Pointer #include <stdlib.h> /* for NULL */... int * p = NULL; 48
49 NULL-Pointer #include <stdlib.h> /* for NULL */... int * p = NULL;... int b = *p; 49
50 NULL-Pointer #include <stdlib.h> /* for NULL */... int * p = NULL;... int b = *p; BANG! 50
51 51 Zusammenfassung NULL markiert Abwesenheit
52 52 Zusammenfassung NULL markiert Abwesenheit NULL-Pointern darf nicht gefolgt werden
53 53 Zusammenfassung NULL markiert Abwesenheit NULL-Pointern darf nicht gefolgt werden Wir müssen wissen, ob ein Pointer NULL ist, bevor wir ihm folgen
54 Pointer auf Pointer
55 55 Anwendungen Mehrdimensionale Arrays
56 Anwendungen Mehrdimensionale Arrays Call by Reference von Pointern 56
57 57 man strtod STRTOD(3) Linux Programmer's Manual STRTOD(3) NAME strtod, strtof, strtold - convert ASCII string to floating-point number SYNOPSIS #include <stdlib.h>... double strtod(const char *nptr, char **endptr); float strtof(const char *nptr, char **endptr);
58 58 man strtod STRTOD(3) Linux Programmer's Manual STRTOD(3) NAME strtod, strtof, strtold - convert ASCII string to floating-point number SYNOPSIS #include <stdlib.h>... double strtod(const char *nptr, char **endptr); float strtof(const char *nptr, char **endptr);
59 59 Pointer auf Pointer int i = 3; int * p = &i;
60 60 Pointer auf Pointer int i = 3; int * p = &i; int ** pp = &p;
61 Variablen im RAM (Wiederholung) 0 RAM int i int ** pp int * p ³²-1 61
62 Von Pointern zu Arrays
63 63 Von Pointern zu Arrays #include <stdio.h> int main() { } return 0;
64 64 Von Pointern zu Arrays #include <stdio.h> void dump(const int * data, int count) { } int main() { } return 0;
65 65 Von Pointern zu Arrays #include <stdio.h> void dump(const int * data, int count) { int i = 0; for (; i < count; ++i) { } } int main() { } return 0;
66 66 Von Pointern zu Arrays #include <stdio.h> void dump(const int * data, int count) { int i = 0; for (; i < count; ++i) { printf(field %d: %d\n, i + 1, *(data + i)); } } int main() { } return 0;
67 67 Von Pointern zu Arrays #include <stdio.h> void dump(const int * data, int count) { int i = 0; for (; i < count; ++i) { printf(field %d: %d\n, i + 1, data[i]); } } int main() { } return 0;
68 68 Von Pointern zu Arrays #include <stdio.h> void dump(const int * data, int count) { int i = 0; for (; i < count; ++i) { printf(field %d: %d\n, i + 1, data[i]); } } int main() { int const primes[] = {2, 3, 5, 7, 11}; } return 0;
69 69 Von Pointern zu Arrays #include <stdio.h> void dump(const int * data, int count) { int i = 0; for (; i < count; ++i) { printf(field %d: %d\n, i + 1, data[i]); } } int main() { int const primes[] = {2, 3, 5, 7, 11}; dump(primes, 5); return 0; }
70 70 Von Pointern zu Arrays #include <stdio.h> void dump(const int * data, int count) { int i = 0; for (; i < count; ++i) { printf(field %d: %d\n, i + 1, data[i]); } } int main() { int const primes[] = {2, 3, 5, 7, 11}; dump(primes, sizeof(primes) / sizeof(int)); return 0; }
71 71 Von Pointern zu Arrays #include <stdio.h> void dump(const int * data, int count) { int i = 0; for (; i < count; ++i) { printf(field %d: %d\n, i + 1, data[i]); } } int main() { int const primes[] = {2, 3, 5, 7, 11, 13}; dump(primes, sizeof(primes) / sizeof(int)); return 0; }
72 72 Zusammenfassung (1/5) Array-Zugriff via [n ] ähnlich Java
73 73 Zusammenfassung (2/5) Array = Pointer auf das erste Element
74 74 Zusammenfassung (3/5) a [n ] = *(a + n )
75 75 Zusammenfassung (4/5) sizeof(variable ) = Von variable belegter Speicher in Byte
76 76 Zusammenfassung (5/5) sizeof(type ) = Von type -Instanzen belegter Speicher in Byte
77 Pointer-Arithmetik
78 Pointer-Arithmetik int numbers[3]; char text[] = software libre; 78
79 Pointer-Arithmetik int numbers[3]; char text[] = software libre; Es gilt: 1. numbers[i] = *(numbers + i)
80 Pointer-Arithmetik int numbers[3]; char text[] = software libre; Es gilt: 1. numbers[i] = *(numbers + i) 2. text[j] = *(text + j) 3. 80
81 Pointer-Arithmetik int numbers[3]; char text[] = software libre; Es gilt: 1. numbers[i] = *(numbers + i) 2. text[j] = *(text + j) 3. sizeof(char) sizeof(int) 81
82 Pointer-Arithmetik int numbers[3]; char text[] = software libre; Es gilt: 1. numbers[i] = *(numbers + i) 2. text[j] = *(text + j) 3. sizeof(char) sizeof(int) Für Operatoren +/- auf Pointern folgt: 82
83 Pointer-Arithmetik int numbers[3]; char text[] = software libre; Es gilt: 1. numbers[i] = *(numbers + i) 2. text[j] = *(text + j) 3. sizeof(char) sizeof(int) Für Operatoren +/- auf Pointern folgt: Sprungweite variiert mit dem Typen! 83
84 Strings
85 85 Strings ABC
86 86 Strings ABC = { 65, 66, 67, 0 }
87 87 Strings ABC = { 65, 66, 67, 0 } 012
88 88 Strings ABC = { 65, 66, 67, 0 } 012 = { 48, 49, 50, 0 }
89 89 Strings ABC = { 65, 66, 67, 0 } 012 = { 48, 49, 50, 0 } 012\0
90 90 Strings ABC = { 65, 66, 67, 0 } 012 = { 48, 49, 50, 0 } 012\0 = { 48, 49, 50, 0, 0 }
91 91 Strings ABC = { 65, 66, 67, 0 } 012 = { 48, 49, 50, 0 } 012\0 = { 48, 49, 50, 0, 0 } #include <string.h>... strlen(abc);
92 92 Strings ABC = { 65, 66, 67, 0 } 012 = { 48, 49, 50, 0 } 012\0 = { 48, 49, 50, 0, 0 } #include <string.h>... strlen(abc); = 3
93 93 my_strlen int my_strlen(const char * str) { } return ( );
94 94 my_strlen int my_strlen(const char * str) { char const * const begin = str; } return ( );
95 95 my_strlen int my_strlen(const char * str) { char const * const begin = str; while (*str) { str++; } return ( ); }
96 96 my_strlen int my_strlen(const char * str) { char const * const begin = str; while (*str) { str++; } return (str - begin); }
97 Const Correctness
98 98 Const Correctness (1/6) Modifikator const verbietet Schreibzugriff
99 99 Const Correctness (2/6) int foo;
100 100 Const Correctness (2/6) const int foo;
101 101 Const Correctness (2/6) int const foo;
102 102 Const Correctness (3/6) int * foo;
103 103 Const Correctness (3/6) int * foo; <1>
104 104 Const Correctness (3/6) int * foo; <2a> <2b> <1>
105 105 Const Correctness (4/6) <1> int * const foo;
106 106 Const Correctness (4/6) <1> int * const foo; Verboten: foo =...;
107 107 Const Correctness (4/6) <1> int * const foo; Verboten: foo =...; <2a> const int * foo; <2b> int const * foo;
108 108 Const Correctness (4/6) <1> int * const foo; Verboten: foo =...; <2a> const int * foo; <2b> int const * foo; Verboten: foo[0] =...;
109 109 Const Correctness (5/6) <2a,1> const int * const foo; <2b,1> int const * const foo;
110 110 Const Correctness (5/6) <2a,1> const int <2b,1> * const foo; int const * const foo; Verboten: foo =...; foo[0] =...;
111 111 Const Correctness (6/6) const int * const * foo;
112 112 Const Correctness (6/6) const int * const * foo; Erlaubt: foo =...;
113 113 Const Correctness (6/6) const int * const * foo; Erlaubt: foo =...; Verboten: foo[0] =...; foo[0][0] =...;
114 114 Const Correctness in APIs int my_strlen( char * str); int my_strlen(const char * str);
115 115 Const Correctness in APIs int my_strlen( char * str); Funktion darf Inhalt von str verändern int my_strlen(const char * str);
116 116 Const Correctness in APIs int my_strlen( char * str); Funktion darf Inhalt von str verändern my_strlen(abc) gibt Compile-Fehler int my_strlen(const char * str);
117 117 Const Correctness in APIs int my_strlen( char * str); Funktion darf Inhalt von str verändern my_strlen(abc) gibt Compile-Fehler int my_strlen(const char * str); Funktion darf Inhalt von str nicht verändern
118 118 Const Correctness in APIs int my_strlen( char * str); Funktion darf Inhalt von str verändern my_strlen(abc) gibt Compile-Fehler int my_strlen(const char * str); Funktion darf Inhalt von str nicht verändern my_strlen(abc) erlaubt und sicher
119 Initialisierung von Strings
120 120 Initialisierung von Strings char a[] = Hallo;
121 Initialisierung von Strings char a[] = Hallo; sizeof(a) = sizeof(char)*(5 + 1) 121
122 Initialisierung von Strings Variante Mit Array char a[] = Hallo; sizeof(a) = sizeof(char)*(5 + 1) 122
123 Initialisierung von Strings Variante Mit Array char a[] = Hallo; sizeof(a) = sizeof(char)*(5 + 1) Inhalt les- und schreibbar 123
124 Initialisierung von Strings Variante Mit Array char a[] = Hallo; sizeof(a) = sizeof(char)*(5 + 1) Inhalt les- und schreibbar Variante Nur Pointer 124
125 Initialisierung von Strings Variante Mit Array char a[] = Hallo; sizeof(a) = sizeof(char)*(5 + 1) Inhalt les- und schreibbar Variante Nur Pointer char * p = Hallo; 125
126 Initialisierung von Strings Variante Mit Array char a[] = Hallo; sizeof(a) = sizeof(char)*(5 + 1) Inhalt les- und schreibbar Variante Nur Pointer char * p = Hallo; sizeof(p) = sizeof(char *) 126
127 Initialisierung von Strings Variante Mit Array char a[] = Hallo; sizeof(a) = sizeof(char)*(5 + 1) Inhalt les- und schreibbar Variante Nur Pointer char * p = Hallo; sizeof(p) = sizeof(char *) Inhalt nicht schreibbar 127
128 Initialisierung von Strings Variante Mit Array char a[] = Hallo; sizeof(a) = sizeof(char)*(5 + 1) Inhalt les- und schreibbar Variante Nur Pointer const char * p = Hallo; sizeof(p) = sizeof(char *) Inhalt nicht schreibbar 128
129 129 Variante Nur Pointer #include <stdio.h> int main() { char * a = hallo; char * b = hallo; } return 0;
130 130 Variante Nur Pointer #include <stdio.h> int main() { char * a = hallo; char * b = hallo; printf(a=%p\n b=%p\n, a, b); } return 0;
131 131 Variante Nur Pointer #include <stdio.h> int main() { char * a = hallo; char * b = hallo; printf(a=%p\n b=%p\n, a, b); a[0] = `X'; } return 0;
132 132 Ausgabe # gcc rombad.c -o rombad
133 Ausgabe # gcc rombad.c -o rombad #./rombad 133
134 Ausgabe # gcc rombad.c -o rombad #./rombad a=0x80484dc b=0x80484dc 134
135 Ausgabe # gcc rombad.c -o rombad #./rombad a=0x80484dc b=0x80484dc 135
136 Ausgabe # gcc rombad.c -o rombad #./rombad a=0x80484dc b=0x80484dc Segmentation fault 136
137 137 GCC Flag -Wwrite-strings # gcc -Wall -Wextra -Wwrite-strings \ rombad.c -o rombad
138 138 GCC Flag -Wwrite-strings # gcc -Wall -Wextra -Wwrite-strings \ rombad.c -o rombad rombad.c: In function `main': rombad.c:4: warning: initialization discards qualifiers from pointer target type rombad.c:5: warning: initialization discards qualifiers from pointer target type
139 139 Variante Nur Pointer #include <stdio.h> int main() { char * a = hallo; char * b = hallo; printf(a=%p\n b=%p\n, a, b); a[0] = `X'; } return 0;
140 140 Variante Nur Pointer #include <stdio.h> int main() { const char * a = hallo; const char * b = hallo; printf(a=%p\n b=%p\n, a, b); a[0] = `X'; } return 0;
141 141 Variante Nur Pointer #include <stdio.h> int main() { const char * a = hallo; const char * b = hallo; printf(a=%p\n b=%p\n, a, b); a[0] = `X'; } return 0;
142 Mehrdimensionale Arrays
143 Mehrdimensionale Arrays Zwei Varianten: Array von Arrays ( deep array ) linear ( flat array ) 143
144 Variante Array von Arrays
145 145 2D-Array als Array von Arrays
146 146 2D-Array als Array von Arrays
147 147 2D-Array als Array von Arrays a
148 148 2D-Array als Array von Arrays a a[0] a[1] 3 4 5
149 149 2D-Array als Array von Arrays a a[0] a[1] a[1][2]
150 150 2D-Array als Array von Arrays int main() { } return 0;
151 2D-Array als Array von Arrays int main() { int row0[] = {0, 1, 2}; int row1[] = {3, 4, 5}; int * const d[] = {row0, row1}; } return 0; 151
152 2D-Array als Array von Arrays int main() { int row0[] = {0, 1, 2}; int row1[] = {3, 4, 5}; int * const d[] = {row0, row1}; demo_deep(d); return 0; } 152
153 2D-Array als Array von Arrays void demo_deep(int * const * a) { } a[1][2] *= 2; int main() { int row0[] = {0, 1, 2}; int row1[] = {3, 4, 5}; int * const d[] = {row0, row1}; demo_deep(d); return 0; } 153
154 Variante Linear
155 155 2D-Array linear
156 156 2D-Array linear a
157 157 2D-Array linear a a[0] a[1] a[1][2]
158 158 2D-Array linear int main() { } return 0;
159 2D-Array linear int main() { int f[][3] = { {0, 1, 2}, {3, 4, 5} }; } return 0; 159
160 2D-Array linear int main() { int f[][3] = { {0, 1, 2}, {3, 4, 5} }; demo_flat(f); return 0; } 160
161 2D-Array linear void demo_flat(int a[][3]) { } a[1][2] *= 2; int main() { int f[][3] = { {0, 1, 2}, {3, 4, 5} }; demo_flat(f); return 0; } 161
162 Variante Hybrid
163 163 2D-Array-Hybrid int main() { } return 0;
164 2D-Array-Hybrid int main() { int f[][3] = { {0, 1, 2}, {3, 4, 5} }; } return 0; 164
165 2D-Array-Hybrid int main() { int f[][3] = { {0, 1, 2}, {3, 4, 5} }; int * const d[] = {f[0], f[1]}; } return 0; 165
166 2D-Array-Hybrid int main() { int f[][3] = { {0, 1, 2}, {3, 4, 5} }; int * const d[] = {f[0], f[1]}; demo_deep(d); demo_flat(f); return 0; } 166
167 2D-Array-Hybrid void demo_deep(int * const * a); void demo_flat(int a[][3]); int main() { int f[][3] = { {0, 1, 2}, {3, 4, 5} }; int * const d[] = {f[0], f[1]}; demo_deep(d); demo_flat(f); return 0; } 167
168 argc und argv
169 169 argc und argv #include <stdio.h> int main() { } return 0;
170 170 argc und argv #include <stdio.h> int main(int argc, char ** argv) { } return 0;
171 171 argc und argv #include <stdio.h> int main(int argc, char ** argv) { printf(%d parameters\n, argc - 1); } return 0;
172 argc und argv #include <stdio.h> int main(int argc, char ** argv) { int i = 0; printf(%d parameters\n, argc - 1); for (; i < argc; ++i) { } } return 0; 172
173 argc und argv #include <stdio.h> int main(int argc, char ** argv) { int i = 0; printf(%d parameters\n, argc - 1); for (; i < argc; ++i) { printf([%d] %s\n, i, argv[i]); } return 0; } 173
174 174 Ausgabe # gcc print_args.c -o print_args
175 Ausgabe # gcc print_args.c -o print_args #./print_args free 'open source' software 175
176 Ausgabe # gcc print_args.c -o print_args #./print_args free 'open source' software 3 parameters [0]./print_args [1] free [2] open source [3] software 176
177 Weiterführende Themen
178 Weiterführende Themen Character Encodings, Unicode, wchar_t Sicherer Umgang mit Strings Der Typ size_t Void-Pointer Funktions-Pointer 178
179 Zusammenfassung
180 Zusammenfassung sizeof(x ) liefert die Größe von x in Byte Operator & liefert eine Adresse Operator * folgt einer Adresse (er dereferenziert) Pointer sind typisiert Arrays sind Pointer auf ihr erstes Element Strings sind nulltermininiert Const Correctness bei Pointern ist wichtig 180
181 181 Danke! Fragen?
C-Kurs 2011: Arrays, Strings, Pointer. Ohne Pointer geht nichts. Willkommen zum dritten Tag des C-Kurses.
Willkommen zum dritten Tag des C-Kurses. C-Kurs 2011: Arrays, Strings, Pointer Sebastian@Pipping.org 15. September 2011 v3.0.35 Mein Name ist Sebastian Pipping. Das dritte Jahr spreche ich nun im Rahmen
Arrays (Felder/Vektoren)
Arrays (Felder/Vektoren) Zusammenfassung mehrerer Variablen des gleichen Typs unter einem Namen im Speicher direkt hintereinander abgelegt Definition: Typname Arrayname [Größe]; Beispiel: int ar [5]; Zugriff
Organisatorisches. Übungsleiter: Karsten Otto Homepage: Aufgaben
Organisatorisches Übungsleiter: Karsten Otto (otto@inf.fu-berlin.de) Homepage: http://www.inf.fu-berlin.de/lehre/ss04/sysi/ Aufgaben Montags im Netz Vorbesprechung Dienstag/Mittwoch in den Übungen Abgabe
Variablen. Deklaration: «Datentyp» «Variablenname» Datentyp bestimmt Größe in Bytes: sizeof Beispiel: long int v; Größe: 4 Bytes
Variablen Deklaration: «Datentyp» «Variablenname» Datentyp bestimmt Größe in Bytes: sizeof Beispiel: long int v; Größe: 4 Bytes v ist Stück im Speicher, der 4 Bytes lang ist Speicherzugriff? Über Adressen!
Programmieren in C. Funktionen mit Zeigern und Adressen. Prof. Dr. Nikolaus Wulff
Programmieren in C Funktionen mit Zeigern und Adressen Prof. Dr. Nikolaus Wulff ByValue versus byreferenz C übergibt immer Kopien der Variablen an Funktionen. Es ist nur dann möglich die Werte von Variablen
Grundlagen der Programmierung in C++ Arrays und Strings, Teil 1
Grundlagen der Programmierung in C++ Arrays und Strings, Teil 1 Wintersemester 2005/2006 G. Zachmann Clausthal University, Germany zach@in.tu-clausthal.de Das C++ Typsystem simple structured integral enum
C allgemein. C wurde unter und für Unix entwickelt. Vorläufer sind BCPL und B.
C-Crash-Kurs Eine kurze, keinesfalls erschöpfende Einführung in die Sprache C für Studierende, die eine strukturierte imperative Programmiersprache beherrschen. Die Vorstellung erfolgt am Beispiel von
Systempraktikum im Wintersemester 2009/2010 (LMU): Vorlesung vom Foliensatz 2
Systempraktikum im Wintersemester 2009/2010 (LMU): Vorlesung vom 29.10. Foliensatz 2 Modularisierung (T) Eigene Headerdateien und Bibliotheken (P) Arten der Parameterübergabe (P) Arrays und Strukturen
Zusammenfassung des Handzettels für Programmieren in C
Zusammenfassung des Handzettels für Programmieren in C In der handschriftlichen Kopie werden mehr Abkürzungen verwendet. Alles Grün markierte dient zum lernen und wird nicht auf den Handzettel übertragen.
Vektoren 105. array-qualifier static restrict const volatile array-size-expression assignment-expression * simple-declarator identifier
Vektoren 105 direct-declarator simple-declarator ( simple-declarator ) function-declarator array-declarator array-declarator direct-declarator [ [ array-qualifier-list ] [ array-size-expression ] ] array-qualifier-list
Dynamischer Speicher
Dynamischer Speicher C-Kurs 2012, 3. Vorlesung Tino Kutschbach tino.kutschbach@campus.tu-berlin.de http://wiki.freitagsrunde.org 13. September 2012 This work is licensed under the Creative Commons Attribution-ShareAlike
10 Die Programmiersprache C99: Zusammenfassung
10 Die Programmiersprache C99: Zusammenfassung Jörn Loviscach Versionsstand: 25. September 2014, 18:40 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen beim Ansehen der Videos: http://www.j3l7h.de/videos.html
7 Funktionen. 7.1 Definition. Prototyp-Syntax: {Speicherklasse} {Typ} Name ({formale Parameter});
S. d. I.: Programieren in C Folie 7-1 7 Funktionen 7.1 Definition Prototyp-Syntax: Speicherklasse Typ Name (formale Parameter); der Funktions-Prototyp deklariert eine Funktion, d.h. er enthält noch nicht
Typ : void* aktuelle Parameter Pointer von beliebigem Typ
2. Funktionen - Prototypvereinbarung typangabe funktionsname(parameterliste); - Funktionsdefinition typ funktionsname(parameterliste){ Anweisung - Funktionstyp -> Typ der Funktionswertes zulaessige Typangaben
Computergrundlagen Programmieren in C
Die Compilersprache C Computergrundlagen Programmieren in C Axel Arnold Institut für Computerphysik Universität Stuttgart Wintersemester 2010/11 Geschichte D. M. Ritchie, *1941 1971-73: Entwickelt von
Übungspaket 14 Eindimensionale Arrays
Übungspaket 14 Eindimensionale Arrays Übungsziele: Skript: Deklaration und Verwendung eindimensionaler Arrays Kapitel: 33 Semester: Wintersemester 2016/17 Betreuer: Kevin, Matthias, Thomas und Ralf Synopsis:
Praxis der Programmierung
Zeichenketten (Strings), Ein- und Ausgabe Institut für Informatik und Computational Science Universität Potsdam Henning Bordihn Einige Folien gehen auf A. Terzibaschian zurück. 1 Zeichenketten (Strings)
Einführung in die Programmiersprache C
Einführung in die Programmiersprache C Marcel Arndt arndt@ins.uni-bonn.de Institut für Numerische Simulation Universität Bonn Der Anfang Ein einfaches Programm, das Hello World! ausgibt: #include
Zeiger, Arrays und Strings in C und C++
Zeiger, Arrays und Strings in C und C++ 1 Zeiger in Java und C/C++ Zeigervariable (kurz: Zeiger, engl.: pointer): eine Variable, die als Wert eine Speicheradresse enthält Java: Zeiger werden implizit für
Advanced Programming in C
Advanced Programming in C Pointer und Listen Institut für Numerische Simulation Rheinische Friedrich-Wilhelms-Universität Bonn Oktober 2013 Überblick 1 Variablen vs. Pointer - Statischer und dynamischer
Einführung in die Programmierung Arrays, Zeiger, Strings. Arvid Terzibaschian
Einführung in die Programmierung Arvid Terzibaschian 1 Arrays 2 Arrays: Motivation Gegeben: monatliche Durchschnittstemperaturen der letzten 5 Jahre Gesucht: Mittelwerte für Jahre, Monate, Jahreszeiten,
3D Programmierpraktikum: Einführung in C++ - Teil 1
3D Programmierpraktikum: Einführung in C++ - Teil 1 Praktikum 3D Programmierung Sebastian Boring, Otmar Hilliges Donnerstag, 27. April 2006 LMU München Medieninformatik Boring/Hilliges 3D Programmierpraktikum
Computergrundlagen Programmieren in C
Computergrundlagen Programmieren in C Axel Arnold Institut für Computerphysik Universität Stuttgart Wintersemester 2013/14 Die Sprache C D. M. Ritchie, 1941 2011 Entwickelt 1971-1973 aktueller Standard:
Übungspaket 29 Dynamische Speicherverwaltung: malloc() und free()
Übungspaket 29 Dynamische Speicherverwaltung malloc() und free() Übungsziele Skript In diesem Übungspaket üben wir das dynamische Alloziieren 1. und Freigeben von Speicherbereichen 2. von Zeichenketten
Einleitung Entwicklung in C Hello-World! Konstrukte in C Zusammenfassung Literatur. Grundlagen von C. Jonas Gresens
Grundlagen von C Jonas Gresens Proseminar C Grundlagen und Konzepte Arbeitsbereich Wissenschaftliches Rechnen Fachbereich Informatik Fakultät für Mathematik, Informatik und Naturwissenschaften Universität
Funktionen Häufig müssen bestimmte Operationen in einem Programm mehrmals ausgeführt werden. Schlechte Lösung: Gute Lösung:
Funktionen Häufig müssen bestimmte Operationen in einem Programm mehrmals ausgeführt werden. Schlechte Lösung: Der Sourcecode wird an den entsprechenden Stellen im Programm wiederholt Programm wird lang
Grundlagen der Programmiersprache C für Studierende der Naturwissenschaften
Grundlagen der Programmiersprache C für Studierende der Naturwissenschaften Teil 5: Funktionen, Gültigkeitsbereiche und Rekursion Martin Nolte Abteilung für Angewandte Mathematik Universität Freiburg i.
Programmiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny
Programmiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny 9. Zeiger Arbeitsspeicher / Adressen Der Arbeitsspeicher des Computers (RAM) besteht aus einem Feld von Speicherzellen, beginnend bei Adresse
Programmieren in C. Eine Einführung in die Programmiersprache C. Prof. Dr. Nikolaus Wulff
Programmieren in C Eine Einführung in die Programmiersprache C Prof. Dr. Nikolaus Wulff Textausgabe per printf Die Funktion printf ist kein Bestandteil der C Sprache sondern gehört zur C Bibliothek. printf
Felder, Rückblick Mehrdimensionale Felder. Programmieren in C
Übersicht Felder, Rückblick Mehrdimensionale Felder Rückblick Vereinbarung von Feldern: typ name [anzahl]; typ name = {e1, e2, e3,..., en} Die Adressierung von Feldelementen beginnt bei 0 Die korrekte
Die Programmiersprache C99: Zusammenfassung
Die Programmiersprache C99: Zusammenfassung Jörn Loviscach Versionsstand: 7. Dezember 2010, 19:30 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen in der Vorlesung. Videos dazu: http://www.youtube.com/joernloviscach
Programmieren in C. Die C-Standardbibliothek. Prof. Dr. Nikolaus Wulff
Programmieren in C Die C-Standardbibliothek Prof. Dr. Nikolaus Wulff Die C-Standard Bibliothek Mit dem C Compiler werden viel fertige Bibliotheksfunktionen ausgeliefert. Eine genaue Kenntnis dieser Funktionen
Grundlagen. Die Komponenten eines C Programms. Das erste Programm
Grundlagen 1. Die Komponenten eines C Programms 2. Ein Programm erzeugen und übersetzen 3. Variablen Deklarieren und Werte zuweisen 4. Zahlen eingeben mit der Tastatur 5. Arithmetische Ausdrücke und Berechnungen
Hello world. Sebastian Dyroff. 21. September 2009
Hello world Sebastian Dyroff 21. September 2009 1 / 35 Inhaltsverzeichnis Organisatorisches Hello World Typen und Operatoren Programmfluss Weitere Konstrukte Nützliche Tipps 2 / 35 Inhalte dieser Veranstaltung
Ein- und Ausgabe. C - Kurs Mario Bodemann. 15. September 2010
Ein- und Ausgabe C - Kurs 2010 Mario Bodemann 15. September 2010 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License 1 / 46 Inhaltsverzeichnis 1 Wiederholung
Dr. Monika Meiler. Inhalt
Inhalt 11 Dynamische Feldvereinbarung... 11-2 11.1 Dynamische Vereinbarung von Vektoren... 11-3 11.2 Dynamische Vereinbarung von Matrizen... 11-5 11.3 Die Kommandozeile... 11-8 Propädeutikum 11-1/8 11
Zeichenketten (Strings) in C
Zeichenketten (Strings) in C Jörn Loviscach Versionsstand: 7. Oktober 2011, 11:27 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen in der Vorlesung. Videos dazu: http://www.j3l7h.de/videos.html
Pointer. Variablen. Pointer. Ein elementares Beispiel. Pointer in C
Variablen Pointer Variable vs. Pointer Dereferenzieren Address-of Operator & Dereference Operarot * Call by Reference Variable = symbolischer Name für Speicherbereich + Information, wie Speicherbereich
Vorkurs C++ Programmierung
Vorkurs C++ Programmierung Funktionen Rückblick Operatoren logische Verknüpfungen Zusammengesetzte Operatoren ( Zuweisungsoperatoren ) Kontrollstrukturen Bedingte Anweisungen (if-abfrage, switch-konstrukt)
Übungspaket 23 Mehrdimensionale Arrays
Übungspaket 23 Mehrdimensionale Arrays Übungsziele: Skript: Deklaration und Verwendung mehrdimensionaler Arrays Kapitel: 49 Semester: Wintersemester 2016/17 Betreuer: Kevin, Matthias, Thomas und Ralf Synopsis:
Lösung Übungszettel 6 Aufgabe 1-4
Lösungen zur Vorlesung GRUNDLAGEN DER INFORMATIK I Studiengang Elektrotechnik WS 02/03 AG Betriebssysteme FB3 Kirsten Berkenkötter Lösung Übungszettel 6 Aufgabe 1-4 1 Aufgabe 1 und 2 1.1 Die Bibliothek
INE1 Mehr zu Funktionen Ausserdem: Strings (Saiten) Call by value, struct's Call by reference Array Parameter Strings und Stringfunktionen
INE1 Mehr zu Funktionen Ausserdem: Strings (Saiten) Call by value, struct's Call by reference Array Parameter Strings und Stringfunktionen 1 Call by Value, Structs 2 von 45 Call by value (Wiederholung)
Übung zur Vorlesung Programmieren in C
Übung zur Vorlesung Programmieren in C 6 Pointers Marvin Gülker Ruhruniversität Bochum Wintersemester 2015/2016 Marvin Gülker (Ruhruniversität Bochum) 6 Pointers Wintersemester 2015/2016 1 / 29 Gliederung
Bereits behandelt: Einfache Datentypen / Variablen. Schleifen und Verzweigungen. Funktionen. Heute: Felder, Zeiger, Referenzen. Freispeicherverwaltung
Kompaktkurs C++ Themen C 1 Bereits behandelt: Einfache Datentypen / Variablen Schleifen und Verzweigungen Funktionen Heute: Felder, Zeiger, Referenzen Freispeicherverwaltung Zeichenketten Kommandozeilenargumente
PROGRAMMIEREN MIT C. }, wird kompiliert mit dem Befehl. (-o steht für output) und ausgeführt mit dem Befehl
PROGRAMMIEREN MIT C Allgemeine hinweise Alles was hier beschrieben wird, soll auch ausprobiert werden. Warum C? Weil die coolen Dinge mit C am einfachsten gehen. Das werden wir in den folgenden Übungen
Modellierung und Programmierung
Modellierung und Programmierung Dr. Martin Riplinger 19.12.2012 IAM Institut für Angewandte Mathematik Funktionszeiger: Vorüberlegungen Funktionsaufrufe sind bis jetzt im Code mit Name explizit angegeben
Die Programmiersprache C Eine Einführung
Die Programmiersprache C Eine Einführung Christian Gentsch Fakutltät IV Technische Universität Berlin Projektlabor 2. Mai 2014 Inhaltsverzeichnis 1 Einführung Entstehungsgeschichte Verwendung 2 Objektorientiert
Grundlagen C und C++ Einheit 03: Grundlagen in C++ Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme
Grundlagen C und C++ Einheit 03: Grundlagen in C++ Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme Teil 1: Wiederholung C Heutige Agenda Nutzereingaben verarbeiten Teil 2: Grundlagen in C++ Erstes
Einleitung. Informationsquellen: - Webseite zur Vorlesung, Abschnitt Informationen zu C und C++ Kurzeinführung in C/C++
Informationsquellen: - Webseite zur Vorlesung, Abschnitt Informationen zu C und C++ 1 Einleitung Vorteile von Java: gut strukturiert mit hohem Funktionsumfang (mächtige Standardbibliothek) weitestgehend
9 Zeiger (Pointer). Dynamischer Speicher
9 Zeiger (Pointer). Dynamischer Speicher Jörn Loviscach Versionsstand: 25. September 2013, 18:07 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen beim Ansehen der Videos: http://www.j3l7h.de/videos.html
RO-Tutorien 3 / 6 / 12
RO-Tutorien 3 / 6 / 12 Tutorien zur Vorlesung Rechnerorganisation Christian A. Mandery WOCHE 2 AM 06./07.05.2013 KIT Universität des Landes Baden-Württemberg und nationales Forschungszentrum in der Helmholtz-Gemeinschaft
Programmiersprachen Einführung in C. Unser erstes C-Programm. Unser erstes C-Programm. Unser erstes C-Programm. Unser erstes C-Programm
Programmiersprachen Einführung in C Teil 2: Prof. Dr. int main (int argc, char *argv[]) int sum = 0; for (i = 0; i
WS03/04 Variablen und Konstanten TFH. Inhaltsverzeichnis. 1.3 Der Adressoperator &
Inhaltsverzeichnis 1 Variablen in Java und in C...1 1.1 Primitive Variablen und Referenzvariablen in Java...1 1.2 Adresstypen in C (ähneln den Referenztypen in Java)...1 1.3 Der Adressoperator &...2 1.4
Programmiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny
Programmiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny 7. Funktionen Einleitung Nach dem Prinzip Divide and Conquer bietet es sich an, größere Aufgaben in kleinere Teile zu unterteilen. Anweisungsblöcke,
Ein- und Ausgabe mit Dateien
Ein- und Ausgabe mit Dateien Edouard Lamboray Informatik I für D-ITET (2004) Ein- und Ausgabekonzepte in C und C++ fstream header Streamobjekt Files schreiben und lesen Argumente von main 2 Vorbemerkungen
Übung HelloWorld /*===========================================================================
Übung HelloWorld /*=========================================================================== Name : HelloWorld.c Description : Hello World Sample! ===========================================================================
3. Arrays und Pointer
C und C++ (CPP) 3. Arrays und Pointer Prof. Dr. Marc Rennhard Institut für angewandte Informationstechnologie InIT ZHAW Zürcher Hochschule für Angewandte Wissenschaften marc.rennhard@zhaw.ch Marc Rennhard,
Bereits behandelt: Einfache Datentypen / Variablen. Schleifen und Verzweigungen. Funktionen. Heute: Felder, Zeiger, Referenzen. Freispeicherverwaltung
Kompaktkurs C++ Themen C 1 Bereits behandelt: Einfache Datentypen / Variablen Schleifen und Verzweigungen Funktionen Heute: Felder, Zeiger, Referenzen Freispeicherverwaltung Zeichenketten Kommandozeilenargumente
Programmieren in C. Speicher anfordern, Unions und Bitfelder. Prof. Dr. Nikolaus Wulff
Programmieren in C Speicher anfordern, Unions und Bitfelder Prof. Dr. Nikolaus Wulff Vergleich: Felder und Strukturen Felder müssen Elemente vom selben Typ enthalten. Strukturen können Elemente unterschiedlichen
Übungspaket 23 Mehrdimensionale Arrays
Übungspaket 23 Mehrdimensionale Arrays Übungsziele: Skript: Deklaration und Verwendung mehrdimensionaler Arrays Kapitel: 49 Semester: Wintersemester 2016/17 Betreuer: Kevin, Matthias, Thomas und Ralf Synopsis:
Zeiger in C und C++ Zeiger in Java und C/C++
1 Zeiger in Java und C/C++ Zeigervariable (kurz: Zeiger, engl.: pointer): eine Variable, die als Wert eine Speicheradresse enthält Java: Zeiger werden implizit für Referenztypen (Klassen und Arrays) verwendet,
Zeichendarstellung. Zeichen sind Zahlen (in C) Zeichen und switch
darstellung Arbeiten mit darstellung werden im Computer durch (kleine) Zahlen dargestellt in C können im Datentyp char gespeichert werden, dieser umfasst ein Byte und gilt als Ganzzahltyp darstellung Arbeiten
Hello World. Javakurs 2014, 1. Vorlesung. Sebastian Schuck. basierend auf der Vorlage von Arne Kappen. wiki.freitagsrunde.org. 3.
Hello World Javakurs 2014, 1. Vorlesung Sebastian Schuck basierend auf der Vorlage von Arne Kappen wiki.freitagsrunde.org 3. März 2014 This work is licensed under the Creative Commons Attribution-ShareAlike
FH Ravensburg-Weingarten Schriftlich Prüfung Programmieren
FH Ravensburg-Weingarten Schriftlich Prüfung Programmieren Prof. Dr. M. Zeller Datum, Zeit Aufgabenblätter erreichbare Punktzahl zugelassene Hilfsmittel, 0800 1000 Uhr (120 min) 16 Seiten (einschl. Deckblatt)
Objektbasierte Entwicklung
Embedded Software Objektbasierte Entwicklung Objektorientierung in C? Prof. Dr. Nikolaus Wulff Objektbasiert entwickeln Ohne C++ wird meist C im alten Stil programmiert. => Ein endlose while-schleife mit
Elementare Datentypen in C++
Elementare Datentypen in C++ bool signed/unsigned char signed/unsigned short int signed/unsigned int signed/unsigned long int (signed/unsigned long long int) float double long double void enum char Der
Programmieren in C. Felder, Schleifen und Fließkommaarithmetik. Prof. Dr. Nikolaus Wulff
Programmieren in C Felder, Schleifen und Fließkommaarithmetik Prof. Dr. Nikolaus Wulff Addition von Zahlen 1 2 3 4 5 #include int main() { int x,y,z,sum; x = 1; y = 2; z = 4; sum = x + y + z;
Lösungsvorschlag zur 9. Übung
Prof. Frederik Armknecht Sascha Müller Daniel Mäurer Grundlagen der Informatik 3 Wintersemester 09/10 Lösungsvorschlag zur 9. Übung 1 Präsenzübungen 1.1 Schnelltest a) Welche der folgenden Aussagen über
U3 3. Übung U3 3. Übung. Systemnahe Programmierung in C Übungen Moritz Strübe Universität Erlangen-Nürnberg Informatik 4, 2009 U3.fm
U3 3. Übung U3 3. Übung Besprechung Aufgabe 1 Pointer Register und Ports U3.1 U3-1 Zeiger U3-1 Zeiger 1 Einordnung Konstante: a 0110 0001 Variable: a Zeiger-Variable (Pointer): a char *p = &a; p U3.2 2
Embedded Toolchain. 1 C/C++-Grundlagen. strncpy_s, strcpy_s etc. V 4.02; Hon. Prof. Helmke 1
1 C/C++-Grundlagen strncpy_s, strcpy_s etc. V 4.02; Hon. Prof. Helmke 1 Anwendung von malloc/free: Dynamische Felder char name[20]; strcpy(name, Helmke ); char* pname;... pname = malloc(sizeof(char)*20);
Embedded SQL in PostgreSQL
7. Dezember 2010 Michael Meskes Seit 1993 Freie Software Seit 1994 Linux Seit 1995 Debian GNU/Linux Seit 1998 PostgreSQL Michael Meskes 1992-1996 Promotion 1996-1998 Projektleiter 1998-2000 Niederlassungsleiter
C Überlebenstraining
C Überlebenstraining Dies ist nur ein Schnellkurs in C, der genug Einstiegswissen vermitteln soll, daß weiterführende Literatur schnell benutzt werden kann. Dies ist kein vollständiger Programmier oder
GI Vektoren
Vektoren Problem: Beispiel: viele Variablen vom gleichen Typ abspeichern Text ( = viele char-variablen), Ergebnisse einer Meßreihe ( = viele int-variablen) hierfür: Vektoren ( = Arrays = Feld ) = Ansammlung
Probeklausur: BTI2 / Programmieren I Prof. Dr. H. Herold Erlaubte Hilfsmittel: Vorlesungsmitschrift; C-Bücher
Probeklausur: BTI2 / Programmieren I Prüfer Prof. Dr. H. Herold Erlaubte Hilfsmittel: Vorlesungsmitschrift; C-Bücher 1. Aufgabe Was gibt das im folgenden angegebene Programm bei seiner Ausführung auf den
Übungen zu Systemprogrammierung 1 (SP1)
Übungen zu Systemprogrammierung 1 (SP1) Ü1-2 Speicherverwaltung Andreas Ziegler, Stefan Reif, Jürgen Kleinöder Lehrstuhl für Informatik 4 Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität
C- Kurs 08 Zeiger. Dipl.- Inf. Jörn Hoffmann leipzig.de. Universität Leipzig Ins?tut für Informa?k Technische Informa?
C- Kurs 08 Dipl.- Inf. Jörn Hoffmann jhoffmann@informa?k.uni- leipzig.de Universität Leipzig Ins?tut für Informa?k Technische Informa?k Überblick Datentyp zur Verwaltung von Adressen (auf Speicherplätze)
Dynamische Speicherverwaltung
Dynamische Speicherverwaltung Tim Dobert 17.05.2013 Inhaltsverzeichnis 1 Allgemeines zur Speichernutzung 2 2 Ziel und Nutzen 2 3 Anwendung in C 2 3.1 malloc............................... 3 3.2 calloc...............................
Tutorium Rechnerorganisation
Woche 2 Tutorien 3 und 4 zur Vorlesung Rechnerorganisation 1 Christian A. Mandery: KIT Universität des Landes Baden-Württemberg und nationales Grossforschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu
16. März 2016 artb5-v1.1
C 16. März 2016 artb5-v1.1 Inhaltsverzeichnis C 2 Was ist ein Programm?........................ 2 Was ist C?............................... 3 Grundgerüst - Hallo Welt....................... 3 Tools und
1.4. Funktionen. Objektorientierte Programmierung mit C++
mehrfache Deklarationen sind erlaubt für jede Funktion muss es (GENAU) eine Definition geben, ansonsten linker error [the one definition rule ODR] Deklarationen in *.h - Files, Definitionen in *.cpp -
2. Programmierung in C
2. Programmierung in C Inhalt: Überblick über Programmiersprachen, Allgemeines zur Sprache C C: Basisdatentypen, Variablen, Konstanten, Operatoren und Ausdrücke Anweisungen und Kontrollstrukturen (Steuerfluss)
Zeiger: Der Adressoperator &
Zeiger: Der Adressoperator & Variablen werden im Computer im Speicher abgelegt. Nach der Deklaration int a,b,c; double x,y,z; Sieht die Speicherbelegung etwa wie folgt aus: a b c x y z Jede Variable hat
Typische Speicherfehler in C
Typische Speicherfehler in C Thorsten Ploß Informatik Universität Hamburg Proseminar: C-Grundlagen und Konzepte 17.05.2013 1 / 13 Inhaltsverzeichnis Einleitung Klassische Speicherverwaltung - Fehlerquellen
6. Bearbeitung von Strings in C Bearbeitung von Strings in C
Bearbeitung von Strings in C 6-1 Definition des String: 6. Bearbeitung von Strings in C Zeichenstrings werden als Felder von Zeichen abgespeichert: char [ ] ; Wie die Daten (Zeichenfolge)
Beispiel für einen IPC-Server, der seinen Dienst über den Global Name Service im Netzwerk bekannt gibt. Header-Dateien einbinden
Dokument: gns_ipc_server.c, 1 - Seite 1 - - 1: 1 von 1 - Beispiel für einen IPC-Server, der seinen Dienst über den Global Name Service im Netzwerk bekannt gibt. Header-Dateien einbinden int main(int argc,
Java Einführung Objekt-Datentypen und Strings. Kapitel 8 und 9
Java Einführung Objekt-Datentypen und Strings Kapitel 8 und 9 Inhalt Was sind Objekt-Datentypen Sonderheiten bei Zuweisung und Vergleich Zeichenketten (Strings) Zeichencodes Char, Char-Arrays und Strings
Programmieren in C++ Einführung
Programmieren in C++ Einführung Inhalt Übersicht über das Modul Einführung in C++ Struktur eines C++-Programms Präprozessor Globale und Modulvariablen Einfache Datentypen Automatische Typinferenz Konstanten
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen 3.3 Mehrdimensionale Arrays W. Tasin, M.Sc. Fakultät 04 tasin@hm.edu Allgemeines (1) Ein Feld (Array) kann seinerseits als Komponente wieder ein Array besitzen. Es wird
Einführung Datentypen Verzweigung Schleifen Funktionen Dynamische Datenstrukturen. Java Crashkurs. Kim-Manuel Klein (kmk@informatik.uni-kiel.
Java Crashkurs Kim-Manuel Klein (kmk@informatik.uni-kiel.de) May 7, 2015 Quellen und Editoren Internet Tutorial: z.b. http://www.java-tutorial.org Editoren Normaler Texteditor (Gedit, Scite oder ähnliche)
Grundlagen C und C++ Einheit 02: Grundlagen in C. Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme
Grundlagen C und C++ Einheit 02: Grundlagen in C Lorenz Schauer Lehrstuhl für Mobile und Verteilte Systeme Heutige Agenda Grundlagen in C Arrays und Zeiger #define Direktive Typdefs und Enums Auf zur Objektorientierung:
Modul 122 VBA Scribt.docx
Modul 122 VBA-Scribt 1/5 1 Entwicklungsumgebung - ALT + F11 VBA-Entwicklungsumgebung öffnen 2 Prozeduren (Sub-Prozeduren) Eine Prozedur besteht aus folgenden Bestandteilen: [Private Public] Sub subname([byval
+ C - Array (Vektoren, Felder)
+ C - Array (Vektoren, Felder) Eindimensionale Arrays Beim Programmieren steht man oft vor dem Problem, ähnliche, zusammengehörige Daten (vom gleichen Datentyp) zu speichern. Wenn man zum Beispiel ein
Zusammengehörige Daten struct. Strukturierte Datentypen und Funktionszeiger. Zugriff auf struct-elemente. Variablendeklarationen mit struct
Zusammengehörige Daten Anstatt logisch zusammengehörende Daten in mehreren unabhängigen Variablen zu speichern, kann man für sie einen eigenen Datentyp ( Verbund, Record ) definieren, der diesen Zusammenhang
Deklarationen in C. Prof. Dr. Margarita Esponda
Deklarationen in C 1 Deklarationen Deklarationen spielen eine zentrale Rolle in der C-Programmiersprache. Deklarationen Variablen Funktionen Die Deklarationen von Variablen und Funktionen haben viele Gemeinsamkeiten.
FH München, FB 03 FA WS 06/07. Ingenieurinformatik. Name Vorname Matrikelnummer Sem.Gr.: Hörsaal Platz
FH München, FB 03 FA WS 06/07 Ingenieurinformatik Name Vorname Matrikelnummer Sem.Gr.: Hörsaal Platz Zulassung geprüft vom Aufgabensteller: Teil I Aufg. 2 Aufg. 3 Aufg. 4 Aufg. 5 Summe Note Aufgabensteller:
Datentypen: Enum, Array, Struct, Union
Datentypen: Enum, Array, Struct, Union C-Kurs 2013, 2. Tutorium Freitagsrunde http://wiki.freitagsrunde.org 10. September 2013 This work is licensed under the Creative Commons Attribution-ShareAlike 3.0
Programmiersprachen Einführung in C
Programmiersprachen Einführung in C Teil 1: Von der Maschinensprache zu C Prof. Dr. Maschinensprache: MIPS R2000 Was bewirkt folgendes Programm: 00100111101111011111111111100000 10101111101111110000000000010100
Programmieren in C. Zeiger und Zeichenketten. Prof. Dr. Nikolaus Wulff
Programmieren in C Zeiger und Zeichenketten Prof. Dr. Nikolaus Wulff Zeiger Variablen benötigen zur Laufzeit einen bestimmten Speicherplatz. Die Größe des Bedarfs richtet sich nach dem Typ der Variablen,
Lösung Übungszettel 6
Lösungen zur Vorlesung GRUNDLAGEN DER INFORMATIK I Studiengang Elektrotechnik SS 03 AG Betriebssysteme FB3 Kirsten Berkenkötter Lösung Übungszettel 6 1 Aufgabe 1: Parallel-Server 1.1 Client #include
Algorithmen und Programmierung II
Algorithmen und Programmierung II Vererbung Prof. Dr. Margarita Esponda SS 2012 1 Imperative Grundbestandteile Parameterübergabe String-Klasse Array-Klasse Konzepte objektorientierter Programmierung Vererbung