Commit a140838e authored by Paffenholz, Andreas's avatar Paffenholz, Andreas

kap 06

parent c0547f53
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger auf Zeigervariablen
*
* Uebersetzen mit
* gcc deref_mult.c -o deref_mult
* Aufruf mit
* ./deref_mult
**************************************/
int main() {
int x = 3;
int * p = &x;
int ** q = &p;
int z1 = x * **q;
int z2 = x * * *q;
int z3 = x * * * q;
int z4 = x * (**q);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger und const
*
* Uebersetzen mit
* gcc funktionszeiger.c -o funktionszeiger
* Aufruf mit
* ./funktionszeiger
**************************************/
int sum(int a, int b) {
return a+b;
}
int main() {
int (*op) (int, int);
op = ∑
int summe = (*op)(4,5); // summe ist 9
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger und const
*
* Uebersetzen mit
* gcc funktionszeigeruebergabe.c -o funktionszeigeruebergabe
* Aufruf mit
* ./funktionszeigeruebergabe
**************************************/
#include <stdio.h>
int sum(int a, int b) {
return a+b;
}
int mul(int a, int b) {
return a*b;
}
void calc(int a, int b, int (*op)(int,int) ) {
printf("Die Berechnung ergibt %d\n", (*op)(a,b));
}
int main() {
calc(2,3,&sum);
calc(2,3,&mul);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Dereferenzieren eines Arrays von Zeigern
*
* Uebersetzen mit
* gcc liste_dereference.c -o liste_dereference
* Aufruf mit
* ./liste_dereference
**************************************/
#include <stdio.h>
int main() {
int x = 1;
int y = 2;
int * liste[2] = {&x, &y};
int *p = &x;
// *p++; // verschiebt erst den Adresszeiger um die Laenge
// eines int und gibt den Inhalt dieses Speicherbereichs aus
// dieser Bereich muss nicht initialisiert sein!
(*p)++; // x ist 2
int z = *liste[1]; // z ist 2
printf("z ist %d\n",z);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Liste, Uebergabe an Funktion
*
* Uebersetzen mit
* gcc liste_referenz.c -o liste_referenz
* Aufruf mit
* ./liste_referenz
**************************************/
int func(int * l, int n) {
int s = 0;
for(int i = 0; i < n; ++i ) {
s += *(l+i);
}
return s;
}
int main() {
int liste[] = {1,2,3,4,5};
int s = func(liste,5); // s ist 15
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Liste, Uebergabe an Funktion
*
* Uebersetzen mit
* gcc liste_referenz-2.c -o liste_referenz_02
* Aufruf mit
* ./liste_referenz_02
**************************************/
#include <stdio.h>
void func(int * l, int n) {
for ( int i = 0; i < n; ++i ) {
printf("[func] Listenelement %d ist an der Adresse %p\n",i,l+i);
}
}
int main() {
int liste[3] = {1,2,3};
for ( int i = 0; i < 3; ++i ) {
printf("[main] Listenelement %d ist an der Adresse %p\n",i,liste[2]+i);
}
func(liste,3);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Liste, Uebergabe an Funktion
*
* Uebersetzen mit
* gcc liste_sizeof.c -o liste_sizeof
* Aufruf mit
* ./liste_sizeof
**************************************/
#include <stdio.h>
int main() {
int liste[3] = {1,2,322};
int * l = liste;
printf("liste zeigt auf einen Speicherbereich der Laenge %lu, l nur auf %lu\n",sizeof(liste), sizeof(l));
printf("Die Liste hat %lu Elemente\n",sizeof(liste)/sizeof(liste[0]));
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Listenvariablen sind Zeiger auf das erste Element
*
* Uebersetzen mit
* gcc liste_zeiger.c -o liste_zeiger
* Aufruf mit
* ./liste_zeiger
**************************************/
#include <stdio.h>
int main() {
int liste[5] = {1,2,3,4,5};
printf("Das erste Element der Liste ist %d\n",liste[0]);
printf("Das erste Element der Liste ist %d\n",*liste);
return 0;
}
void f1(int n, int m, int (*mat)[m]) {
// Anweisungen
}
void f2(int n, int m, int mat[n][m]) {
// Anweisungen
}
void f3(int n, int m, int mat[][m]) {
// Anweisungen
}
int sum(int a, int b) {
return a+b;
}
int main() {
int n = 3;
int m = 2;
int mat[n][m];
int (*fp)(int,int) = &sum;
int x = (*fp)(2,3);
f1(n,m,mat);
f2(n,m,mat);
f3(n,m,mat);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Speichegroessen
*
* Uebersetzen mit
* gcc sizeof.c -o sizeof
* Aufruf mit
* ./sizeof
**************************************/
#include <stdio.h>
int main() {
printf("Die Speichergroesse von int ist %lu.\n",sizeof(int) );
printf("Die Speichergroesse von char ist %lu.\n",sizeof(char) );
printf("Die Speichergroesse von double ist %lu.\n",sizeof(double) );
long x = 4;
printf("Die Speichergroesse von x ist %lu.\n",sizeof(x) );
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger 01
*
* Uebersetzen mit
* gcc zeiger_01.c -o zeiger_01
* Aufruf mit
* ./zeiger_01
**************************************/
#include <stdio.h>
int main() {
int x = 5;
int* p = &x;
printf("An der Adresse %p ist der Wert %d gespeichert.\n", p, *p);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger 02
*
* Uebersetzen mit
* gcc zeiger_02.c -o zeiger_02
* Aufruf mit
* ./zeiger_02
**************************************/
#include <stdio.h>
int main() {
int a = 5;
int *x = &a;
*x = 7;
printf("a ist %d\n",a);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger auf Zeigervariablen
*
* Uebersetzen mit
* gcc zeiger_aendern.c -o zeiger_aendern
* Aufruf mit
* ./zeiger_aendern
**************************************/
#include <stdio.h>
void max(int ** p, int * a, int * b) {
if ( *a < *b ) {
*p = b;
} else {
*p = a;
}
}
int main() {
int x = 3;
int y = 5;
int * p;
max(&p,&x,&y);
printf("Das Maximum von %d und %d ist %d\n", x, y, *p);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger auf Zeigervariablen
*
* Uebersetzen mit
* gcc zeiger_auf_zeiger.c -o zeiger_auf_zeiger
* Aufruf mit
* ./zeiger_auf_zeiger
**************************************/
#include <stdio.h>
int main() {
int x = 3;
int * p = &x;
int ** q = &p;
printf("x ist %d\n",**q);
int y = x* **q;
printf("y ist %d\n",y);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger und const
*
* Uebersetzen mit
* gcc zeiger_const_01.c -o zeiger_const_01
* Aufruf mit
* ./zeiger_const_01
**************************************/
int main() {
int x = 4;
int y = 5;
int * const p1 = &x;
*p1 = 6; // jetzt ist x == 6
p1 = &y; // Fehler, p kann nicht auf eine andere Adresse zeigen
const int z = 7;
const int * const p2 = &z;
p2 = &x; // Fehler, p kann nicht auf eine andere Adresse zeigen
*p2 = 8; // Fehler, Wert an der Adresse p2 unveraenderlich
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger und const
*
* Uebersetzen mit
* gcc zeiger_const_02.c -o zeiger_const_02
* Aufruf mit
* ./zeiger_const_02
**************************************/
int main() {
int x = 5;
const int * p1 = &x;
*p1 = 6; // Fehler, *p1 unveraenderlich
x = 7; // jetzt ergibt *p1 ebenfalls 7
const int y = 8;
int * p2 = &y; // erzeugt eine Warnung, keinen Fehler
*p2 = 9; // jetzt ist y == 9
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Die Adresse NULL
*
* Uebersetzen mit
* gcc zeiger_null.c -o zeiger_null
* Aufruf mit
* ./zeiger_null
**************************************/
#include <stdio.h>
int main() {
int * p = NULL;
printf("p zeigt auf %p\n",p);
int x = 4;
if ( p == NULL ) {
p = &x;
}
printf("p zeigt jetzt auf %p\n",p);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeiger, Uebergabe an Funktion
*
* Uebersetzen mit
* gcc zeiger_referenz.c -o zeiger_referenz
* Aufruf mit
* ./zeiger_referenz
**************************************/
#include <stdio.h>
void change(int* p) {
p++;
}
int main() {
int a = 1;
change(&a); // wir uebergeben die Adressse von a
printf("a ist %d\n",a); // gibt "a ist 2" aus
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Zeigerarithmetik
*
* Uebersetzen mit
* gcc liste_zeiger_02.c -o liste_zeiger_02
* Aufruf mit
* ./liste_zeiger_02
**************************************/
int main() {
int liste[5] = {1,2,3,4,5};
int x = liste[3]; // x ist 4
int y = *(liste+3); // ebenfalls 4
int * p = liste+3; // zeigt auf das vierte Element der Liste
return 0;
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment