C-Programm – Matrix-Addition

Mit diesen kleinen Programmen kann man Matrix-Addition durchführen, indem die Werte der Matrizen jeweils zusammengerechnet werden. In dem zweiten Programm habe ich mit Funktionen und Pointeren gearbeitet.

/*
 ============================================================================
 Name        : matrix-addition_1.c
 Author      : Voku
 Version     : 1.0
 Description : Matrix-Addition
 ============================================================================
 */

#include <stdio.h>
#define MAX_ZEILEN 10
#define MAX_SPALTEN 10

int main (void) {
	int index_zeile, zeile, index_spalte, spalte;
	double array_a[MAX_ZEILEN][MAX_SPALTEN], array_b[MAX_ZEILEN][MAX_SPALTEN], array_c[MAX_ZEILEN][MAX_SPALTEN];

	// Anzahl der Zeilen einlesen
	do {
		printf("Anzahl der Zeilen (1-%i): ",MAX_ZEILEN);
		scanf("%i",&zeile);
		if (zeile > MAX_ZEILEN ) {
			printf("\n zu viel Zeilen...\n\n");
		} else if (zeile < 1) {
			printf("\n zu wenig Zeilen...\n\n");
		}
	} while (zeile > MAX_ZEILEN || zeile < 1);
	printf("\n");
	// Anzahl der Spalten einlesen
	do {
		printf("Anzahl der Spalten (1-%i): ",MAX_SPALTEN);
		scanf("%i",&spalte);
		if (spalte > MAX_SPALTEN ) {
			printf("\n zu viel Spalten...\n\n");
		} else if (zeile < 1) {
			printf("\n zu wenig Spalten...\n\n");
		}
	} while (spalte > MAX_SPALTEN || spalte < 1);
	printf("\n");

	// Werte fuer Matrize 1 einlesen
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
  			printf("Wert fuer Zeile %i und Spalte %i (Matrize 1) eingeben: ",index_zeile+1, index_spalte+1);
        		scanf("%lf",&array_a[index_zeile][index_spalte]);
    		}
    	}
	printf("\n");
    	// Werte fuer Matrize 2 einlesen
    	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
    			printf("Wert fuer Zeile %i und Spalte %i (Matrize 2) eingeben: ",index_zeile+1, index_spalte+1);
        		scanf("%lf",&array_b[index_zeile][index_spalte]);
    		}
    	}

	// Array A und B addieren und in Array C schreiben
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
        		array_c[index_zeile][index_spalte]=array_a[index_zeile][index_spalte]+array_b[index_zeile][index_spalte];
    		}
	}

	// Ausgabe
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		printf("\n (");
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
        		printf(" %.2lf", array_a[index_zeile][index_spalte]);
        	}
		printf(" ) ");
	}
	printf("\n\n +\n");
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		printf("\n (");
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
			printf(" %.2lf", array_b[index_zeile][index_spalte]);
		}
		printf(" ) ");
	}
	printf("\n\n =\n");
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		printf("\n (");
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
			printf(" %.2lf", array_c[index_zeile][index_spalte]);
    		}
		printf(" ) ");
	}

	return 0;
}
/*
 ============================================================================
 Name        : matrix-addition_2.c
 Author      : Voku
 Version     : 1.0
 Description : Matrix-Addition mit Funktionen (+Pointer)
 ============================================================================
 */

#include <stdio.h>
#define MAX_ZEILEN 10
#define MAX_SPALTEN 10

void matrix_addition (double *array_a, double *array_b, double *array_c, int zeile, int spalte) {
	int index_zeile, index_spalte;
	// printf("*array_a %lf\n*array_b %lf\n*array_c %lf\n", *array_a, *array_b, *array_c); // TEST-Ausgabe
	for(index_zeile=0; index_zeile < zeile; index_zeile++) {
		for(index_spalte=0; index_spalte < spalte; index_spalte++) {
			*(array_c + (index_zeile * spalte) + index_spalte) = *(array_a + (index_zeile * spalte) + index_spalte) + *(array_b + (index_zeile * spalte) + index_spalte);
		}
		printf("\n");
	}
}

void matrix_ausgabe (double *matrix, int zeile, int spalte) {
	int index_zeile, index_spalte;
	// printf("*matrix %lf", *matrix); // TEST-Ausgabe
	printf("\n\n");
	for(index_zeile=0; index_zeile < zeile; index_zeile++) {
		for(index_spalte=0; index_spalte < spalte; index_spalte++) {
			printf(" %.2lf", *(matrix + (index_zeile * spalte) + index_spalte));
		}
		printf("\n");
	}
}

int main (void) {
	int index_zeile, zeile, index_spalte, spalte;

	// Anzahl der Zeilen einlesen
	do {
		printf("Anzahl der Zeilen (1-%i): ",MAX_ZEILEN);
		scanf("%i",&zeile);
		if (zeile > MAX_ZEILEN ) {
			printf("\n zu viel Zeilen...\n\n");
		} else if (zeile < 1) {
			printf("\n zu wenig Zeilen...\n\n");
		}
	} while (zeile > MAX_ZEILEN || zeile < 1);
	printf("\n");
	// Anzahl der Spalten einlesen
	do {
		printf("Anzahl der Spalten (1-%i): ",MAX_SPALTEN);
		scanf("%i",&spalte);
		if (spalte > MAX_SPALTEN ) {
			printf("\n zu viel Spalten...\n\n");
		} else if (zeile < 1) {
			printf("\n zu wenig Spalten...\n\n");
		}
	} while (spalte > MAX_SPALTEN || spalte < 1);
	printf("\n");

	double array_a[zeile][spalte], array_b[zeile][spalte], array_c[zeile][spalte];

	// Werte fuer Matrize 1 einlesen
	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
    			printf("Wert fuer Zeile %i und Spalte %i (Matrize 1) eingeben: ",index_zeile+1, index_spalte+1);
        		scanf("%lf",&array_a[index_zeile][index_spalte]);
    		}
	}
    	printf("\n");
    	// Werte fuer Matrize 2 einlesen
    	for (index_zeile=0; index_zeile < zeile; index_zeile++) {
    		for ( index_spalte=0; index_spalte < spalte; index_spalte++) {
    			printf("Wert fuer Zeile %i und Spalte %i (Matrize 2) eingeben: ",index_zeile+1, index_spalte+1);
        		scanf("%lf",&array_b[index_zeile][index_spalte]);
    		}
	}

	// printf("zeile + spalta: %i, %i", zeile, spalte); // TEST-Ausgabe

	// Array A und B addieren und in Array C schreiben
	matrix_addition(&array_a[0][0], &array_b[0][0], &array_c[0][0], zeile, spalte);

	// Ausgabe
	matrix_ausgabe(&array_a[0][0], zeile, spalte);
	printf("\n +");
	matrix_ausgabe(&array_b[0][0], zeile, spalte);
	printf("\n =");
	matrix_ausgabe(&array_c[0][0], zeile, spalte);

	return 0;
}

C-Programm – Skalarprodukt

Hier ein kleines Programm, welches das Skalarprodukt von zwei Vektoren berechnet…

/*
 ============================================================================
 Name        : Skalarprodukt.c
 Author      : Voku
 Version     : 1.0
 Description : Skalarprodukt zweier Vektoren
 ============================================================================
 */

#include <stdio.h>
#define MAX 10

int main(void) {
    double vektor1[MAX],vektor2[MAX];  	// Arrays fuer Vektoren (1 und 2)
    int anzahl;      			// Anzahl der Vektoren
    int index;       			// Wert im Array
    double produkt;     		// einzelnes Produkt
    double ergebnis=0.0;  		// Gesamtwert aller Produkte

    printf("Skalarprodukt (innere Produkt) zweier beliebiger Vektoren berechnen:\n\n");

    do {
    	printf("Anzahl der Elemente pro Vektordimension (1-%i):" ,MAX);
        scanf("%i",&anzahl);
        if (anzahl > MAX ) {
        	printf("\n zu viel Dimension...\n\n");
        } else if (anzahl < 1) {
        	printf("\n zu wenig Dimension...\n\n");
        }
    } while (anzahl > MAX || anzahl < 1);

    // Vektorwerte fuer Vektor 1 einlesen
    for (index=0; index < anzahl; index++) {
    	printf("Wert %i fuer Vektor 1 eingeben: ",index+1);
    	scanf("%lf",&vektor1[index]);
    }
    // Vektorwerte fuer Vektor 2 einlesen
    for (index=0; index < anzahl; index++) {
    	printf("Wert %i fuer Vektor 2 eingeben: ",index+1);
    	scanf("%lf",&vektor2[index]);
    }

    // Berechnung des Skalarproduktes
    for(index=0; index < anzahl; index++) {
    	produkt = vektor1[index] * vektor2[index];
    	ergebnis += produkt;
    }

    // Ausgabe
    printf("Skalarprodukt: %.4lf\n",ergebnis);

    return 0;
}

C-Programm – Euro & Dollar Umrechnung

Und noch ein einfaches Beispiel für Funktionen… + verschiedenen Schleifen. (for, while, do-while)

// Euro & Dollar

#include <stdio.h>
#define WKURS 1.40331182

double euro2dollar( double euro) {
	return euro*WKURS;
}

double dollar2euro( double dollar) {
	return dollar/WKURS;
}

int main(void) {
	double anfangsbetrag;
	double endbetrag;
	int umrechnung;

	printf("Umrechnen von Dollar in Euro & von Euro in Dollar:\n\n");
	do {
		printf("Anfangsbetrag = "); scanf("%lf", &anfangsbetrag);
	} while ( anfangsbetrag <= 0 );
	do {
		printf("Endbetrag = "); scanf("%lf", &endbetrag);
	} while ( endbetrag <= 0 );

	do {
		printf("\n1 - von Euro in Dollar\n2 - von Dollar in Euro\nUmrechnung:"); scanf("%d", &umrechnung);
	} while ( (umrechnung < 1)  || (umrechnung > 2) );

	if (umrechnung == 1) {
		printf("\n  Euro  |  Dollar");
		printf("\n--------+--------");
		// for
		for (anfangsbetrag; anfangsbetrag <= endbetrag; anfangsbetrag=anfangsbetrag+10) {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, euro2dollar(anfangsbetrag) );
		}
		/* // while
		while (anfangsbetrag <= endbetrag) {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, euro2dollar(anfangsbetrag) );
			anfangsbetrag=anfangsbetrag+10;
		}
		*/
		/* // do-while
		do {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, euro2dollar(anfangsbetrag) );
			anfangsbetrag=anfangsbetrag+10;
		} while (anfangsbetrag <= endbetrag);
		*/
	} else {
		printf("\nDollar  |    Euro");
		printf("\n--------+--------");
		for (anfangsbetrag; anfangsbetrag <= endbetrag; anfangsbetrag=anfangsbetrag+10) {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, dollar2euro(anfangsbetrag) );
		}
		/* // while
		while (anfangsbetrag <= endbetrag) {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, dollar2euro(anfangsbetrag) );
			anfangsbetrag=anfangsbetrag+10;
		}
		*/
		/* // do-while
		do {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, dollar2euro(anfangsbetrag) );
			anfangsbetrag=anfangsbetrag+10;
		} while (anfangsbetrag <= endbetrag);
		*/
	}

	return 0;
}

C-Programm – eulersche Zahl

Hier noch ein Beipspiel für eine Funktion, in welcher die „eulersche Zahl“ zu einem bestimmten Exponenten berechnet wird…

#include <stdio.h>

/* 

Die Exponentialfunktion e^x kann als eine unendliche Reihe geschrieben werden, um sich dem Ergebnis anzunaehern!!!

------
e^x = 1 + x + x²/2! + x³/3! + x⁴/4! + ... = 1 + x + 1/2*x² + 1/6*x³ + 1/24*x⁴ + ...  
------

i! ist hier die Fakultaet von i und ist definiert als

------
i! = 1*2*3* ... *(i-1)*i
------

- 1.) die Fakultaet ist fortlaufend mit den aufsteigenden ganzen Zahlen zu multiplizieren
- 2.) die Potenz ist fortlaufend mit Exponenten zu multiplizieren
- 3.) die Summanden koennen aus Fakultaet & Potenz berechnet werden
- 4.) die Summenbildung wird abgebrochen, wenn die Summanden kleiner als eine bestimmte Genauigkeit (Epsilon) werden

*/

double exp_fkt( double exponent) {
	int fakultaet=1; /* i! */
	double potenz=1.0; /* x^i */
	double resultat=1.0, summanden;
	int n=1;

	do {
		fakultaet *= n; // 1.)
		potenz *= exponent; // 2.)
		summanden = potenz/fakultaet; // 3.)
		resultat = resultat + summanden;
		printf("%3d %12d %12.6f %12.6f\n", n, fakultaet, summanden, resultat); // test - Ausgabe
		n++;
	} while (summanden >= 0.0001); // 4.)

	return resultat;
}

int main(void) {
	double exponent;

	printf("Berechnung von e^x\n\n");
	printf("Exponent = "); scanf("%lf", &exponent);

	printf("\nDurchlauf Fakultaet Summanden Resultat\n");
	printf("----------------------------------------\n");
	printf("\nexp(%.1lf) = %.16lf\n", exponent, exp_fkt(exponent));

	return 0;
} 

C-Programm – Funktionen

Dies kurze Beispiel zeigt das Prinzip von Funktionen… und wie man das Maximum von drei Zahlen ausgibt. ;-)

#include <stdio.h>

// Funktion_1: max_1 (Maximum) mit drei Eingaengen
int max_1 (int a, int b, int c) {
	if(a>b && a>c)
		return a;
	else if(b>a && b>c)
		return b;
	else
		return c;
}

// Funktion_2: max_2 (Maximum) mit zwei Eingaengen
int max_2 (int a, int b) {
	if(a>b)
		return a;
	else
		return b;
}

int main (void){

	int a,b,c,max_3;

	printf("a");
	scanf("%d",&a);
	printf("b");
	scanf("%d",&b);
	printf("c");
	scanf("%d",&c);

	// Funktion_1
	printf ("%d", max_1(a,b,c));

	// Funktion_2 (wird 2-mal ineinander ausgefuehrt)
	printf ( "%d", max_2(max_2(a,b),c) );

	// alles in einer Zeile :-)
	max_3 = (a>b) ? ((a>c) ? a : c) : ((b>c) ? b : c);
	printf("%d", max_3);

	return (0);
}

C-Programm – Umrechnung von Zahlensystemen

Das Programm kann dezimale Zahlen in andere Zahlensysteme umrechnen… sowohl Vorkomma- als auch Nachkommastellen.

#include <stdio.h>

int main(void) {
	float kommazahl, kommazahl_darstellung;
	float array_kommazahl[32], array_kommazahl_ergebnis[32];
	char array_rest[32];
	int y=0, zahl, rest, ergebnis;
	int i=0, j=0, loop=0, basis, genauigkeit=30;

	/* mache etwas (min. 1-mal) ... */
	do { 
		printf("Bitte eine positive Kommazahl eingeben:");
		scanf("%f", &kommazahl);
	/* ... solange die Eingabe kleiner 0 */
	} while (kommazahl < 0);

	/* mache etwas (min 1-mal) ... */
	do {
		printf("Bitte eine Basis >=2 ein:");
		scanf("%d", &basis);
	/* ... solange die Eingabe kleiner 2 */ 
	} while (basis < 2 );

/*
	z.B.: die Dezimalzahl 8 soll ins 2er-System umgewandelt werden

	Verfahren:
	(1) Teile die Zahl mit Rest durch 2.
	(2) Der Divisionsrest ist die naechste Ziffer (von rechts nach links).
	(3) Falls der (ganzzahlige) Quotient = 0 ist, bist du fertig,
		andernfalls nimm den (ganzzahligen) Quotienten als neue Zahl 
		und wiederhole ab (1).

	8 : 2 = 4  Rest: 0
	4 : 2 = 2  Rest: 0
	2 : 2 = 1  Rest: 0
	1 : 2 = 0  Rest: 1

	-> Resultat: 1000
*/

	printf ("\nV O R K O M M A S T E L L E N:\n\n");

	/* nur die Vorkommastellen (Integer = ganze Zahl) in die Variable 'zahl' schreiben */
    zahl = (int) kommazahl;

	while (zahl > 0) { // (3)
		rest = zahl % basis; // (1)
		array_rest[y++] = rest; // Array fuer die umgekehrte Reihenfolge der Ausgabe
		ergebnis = zahl / basis;
		printf("%d : %d = %d  Rest: %d\n", zahl, basis, ergebnis, rest); // Ausgabe 
		zahl = zahl / basis; // (2)
	}

	printf("\n-> Resultat: ");
	while (--y >= 0) { // umgekehrte Reihenfolge der Ausgabe
 		printf("%d", array_rest[y]);
	}


/* 
	z.B: der Dezimalbruch  0,8  soll ins 2er System umgewandelt werden

	Verfahren fuer Nachkommaziffern:
	(1) Multipliziere die Zahl mit der Basis 2
	(2) Die Zahl vor dem Komma ist die naechste Ziffer des Ergebnisses
	(3) Schneide die Zahl vor dem Komma weg.
	(4) Wiederhole ab (1), bis der Rest 0 ist, sich ein Rest wiederholt
		oder die gewuenschte Genauigkeit erreicht ist.

	2 · 0,8 = 1,6    --> Ziffer: 1
	2 · 0,6 = 1,2    --> Ziffer: 1
	2 · 0,2 = 0,4    --> Ziffer: 0
	2 · 0,4 = 0,8    --> Ziffer: 0
	2 · 0,8 = 1,6    --> Ziffer: 1

	Der "Rest" 1,6 trat im 1. Schritt bereits auf.
	Ab dort wiederholen sich die Nachkommaziffern periodisch.

	-> Resultat: 0,1100110011001100110011001100110011001100110011001100...
*/

	printf ("\n\n\nN A C H K O M M A S T E L L E N:\n\n");

	kommazahl = kommazahl - (int) kommazahl; // z.B. kommazahl = 2,5 - 2 = 0,5
	kommazahl_darstellung = kommazahl; // nur zur Veranschaulichung in der Ausgabe

	do {
		kommazahl *= basis; // (1)
		kommazahl = ( (int) (kommazahl * 1000.0 + 0.5)) / 1000.0; // Runden auf 4 Nachkommastellen
		array_kommazahl[j] = kommazahl; // Restwert in ein Array schreiben

		for ( j=0; j < i; j++ ) { 
			// printf("\ntest - [%d][%d] - %f\n", i, j, array_kommazahl[j]); // test - Ausgabe
			if ( array_kommazahl[j] == kommazahl ) { // (4) - Wiederholung feststellen
				loop = j;
			}
		}

		if ( (int) kommazahl == 0 && loop == 0) { // (2)
			printf ("%d * %.1f = %.1f  --> Ziffer: %d\n", basis, kommazahl_darstellung, kommazahl, (int) kommazahl); // Ausgabe
			array_kommazahl_ergebnis[j] = (int) kommazahl;
		} else if ( (int) kommazahl != 0 && loop == 0) { // (2) 
			printf ("%d * %.1f = %.1f  --> Ziffer: %d\n", basis, kommazahl_darstellung, kommazahl, (int) kommazahl); // Ausgabe
			array_kommazahl_ergebnis[j] = (int) kommazahl;
			kommazahl -= (int) kommazahl; // (3)
		}

		if ( loop >= 1 ) {
			printf ("\nDer \"Rest\" von %f trat im %d. Schritt bereits auf.\nAb dort wiederholen sich die Nachkommaziffern periodisch.\n", array_kommazahl[j-1], loop); 
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
		}

		if ( kommazahl == 0.0 ) {
			printf ("\nEs ist kein Rest mehr uebrig... :-)");
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
		}

		if ( i >= genauigkeit ) {
			printf ("\nDie Genauigkeit sollte nun ausreichen... (%d Bit)", genauigkeit);
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
			break;
		}

		kommazahl_darstellung *= basis; // nur zur Veranschaulichung in der Ausgabe
		kommazahl_darstellung = ( (int) (kommazahl_darstellung * 1000.0 + 0.5)) / 1000.0; // nur zur Veranschaulichung in der Ausgabe
		kommazahl_darstellung -= (int) kommazahl_darstellung; // nur zur Veranschaulichung in der Ausgabe

		i++;
		j++;
//	} while ( ( i < genauigkeit ) || !(!(loop == 0 && kommazahl != 0.0 ) && !(loop == 0 && kommazahl != 0.0 )) ); // (4) + Logisches XOR
	} while ( !(!(loop == 0 && kommazahl != 0.0 ) && !(loop == 0 && kommazahl != 0.0 )) ); // (4) + Logisches XOR

	return(0);
}

C-Programm – doppelte Schleife

In diesem Beispiel zeige ich, wie sich eine doppelte Schleife auswirkt…

#include 

main() {
    /* Integer (ganze Zahl) */
    int x,y;

    /* die erste Schleife wird 10-mal durchlaufen */
    for(x=1; x< =10; x=x+1) {
        /* als erstes wird ein Zeillenumbruch (\n) dargestellt */
        printf("\n");

        /* die zweite Schleife befindet sich in der ersten,
           so dass diese jeweills 10*20-mal durchlaufen wird */
        for(y=1; y<=20; y=y+1) {
            /* Feldbreite von 4-Stellen (1234,  34,   4),
               nun wird 1*1, 1*2 [20-mal],
               dann     2*1, 2*2 [20-mal] gerechnet */
            printf("%4i", x*y);
        }
    }
}

/*
   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36  38  40
   3   6   9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54  57  60
   4   8  12  16  20  24  28  32  36  40  44  48  52  56  60  64  68  72  76  80
   5  10  15  20  25  30  35  40  45  50  55  60  65  70  75  80  85  90  95 100
   6  12  18  24  30  36  42  48  54  60  66  72  78  84  90  96 102 108 114 120
   7  14  21  28  35  42  49  56  63  70  77  84  91  98 105 112 119 126 133 140
   8  16  24  32  40  48  56  64  72  80  88  96 104 112 120 128 136 144 152 160
   9  18  27  36  45  54  63  72  81  90  99 108 117 126 135 144 153 162 171 180
  10  20  30  40  50  60  70  80  90 100 110 120 130 140 150 160 170 180 190 200
*/

C-Programm – Kommandozeilenparameter

In diesem Beispiel zeige ich, wie du Parameter in einem C-Programm einsetzen kannst…

/* 
read_args.c 

Achtung: 
        - bei Platzhaltern (*) !!! Wird hier noch nicht beruecksichtigt
        - die Hilfe ist nur per '-h' und nicht '--help' aufrufbar
        - Fehlermeldungen werden nicht ausgegeben
*/

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
        int option, i;
        char *out_filename=NULL;

        /* argc -> Anzahl Kommandozeilenparameter + Programmnamen (1), somit ist der Wert min. 1 */

        /* argv -> ist ein Zeiger auf das Feld (Array) mit der in argc angegebene Anzahl von Elementen...
                   ... und die Elemente (z.B.: argc[0] sind Zeiger auf eine Zeichenkette...

                   arg[0] -> Programmname
                   arg[1] -> 1. Parameter 
                   arg[2] -> 2. Parameter
                   [...]
                   arg[n] -> letzter Parameter
                    0L    -> das letzte Element von argv[] einthaelt eine Null
        */

        /* 
           getopt() sortiert zunaechst das Feld argc[] 
           1. Optionen
           2. Argumente

           Rueckgabewert: erste in der Kommandozeile angegebene Option oder -1 wenn keine Option angegeben wurde...
                          ... beim naechen Durchlauf jeweills die naechste angegebene Option...
                          ... und zum Schluss -1

           x:  -> 'x' waehre hier eine Option
           x:: -> 'x' waehre hier eine optinale Option
           xy: -> 'x' und 'y' waehren hier die Optionen (Optionsliste)  
        */
        while((option = getopt(argc, argv, "ho:")) >= 0) {
                switch(option) {
                        case 'h':
                                printf("Usage: %s [-o output-file] [input-file ...]\n", argv[0]);
                                return(0);
                        case 'o':
                                out_filename = optarg;
                                break;
                        /* wenn ein unzulaessige Option angegeben wurde, gibt getopt() ein '?' aus */
                        case '?':
                                return(1); /* unbekannte Option ... Abbruch */
                }
                /* die globale Variable 'optind' gibt den Index des ersten Arguments dem Feld argv[] weiter */
                for (i=optind; i<argc; i++) {
                        printf("'%s'\n", argv[i]);
                }
                if (out_filename) {
                        printf("output is '%s'\n", out_filename);
                }
        }
        return(0);
}

/*
Ausgabe:
./read_args -o test1 1 2 3 4 5 
'1'
'2'
'3'
'4'
'5'
output is 'test1'
*/

C-Programm – Primzahlen & Makefiles

Das folgende Programm gibt alle Primzahlen von 1 bis 100 aus, dabei wurde die Berechnung in eine eigene Funktion ausgelager.

/*
primzahlen.c
*/

#include <stdio.h>
#include <math.h>

/*
gcc -Wall -lm primzahlen.c -o primzahlen -O3
*/

int ist_primzahl(int zahl) {
    int teiler=2;

    /* solange der 'teiler' kleiner/gleich der (²)Wurzel aus 'zahl' ist ...
    ...  denn Primzahlen haben -keinen- Teiler der kleienr als dessen Quadratwurzel ist */
    while (teiler <= sqrt(zahl)) {
    /* alternativ, dann ohne <math.h> */
    /* while (teiler*teiler <= zahl) { */
        /* wenn kein Rest, dann... */
        if (zahl % teiler == 0) {
            /* ... 'false' */
            return(0);  /* 'zahl' ist keine Primzahl */
        }
        /* teiler und einen erhoehen */
        teiler++;
    }
    /* ... ansonsten 'true' */
    return(1);          /* 'zahl' ist eine Primzahl */
}

int main() {
    int zahl;

    /* solange bis 1 nicht mehr kleiner/gleich 100 bis, 1 erhoehen */
    for (zahl=1; zahl<=100; zahl++) {
        /* wenn Funktion='true' dann ...*/
        if (ist_primzahl(zahl)) {
            /* ... Zahl ausgebn */
            printf("%d\n", zahl);
        }
    }
    return(0);
}


Bei großen Projekten kann es hilfreich sein, diese Funktionen in verschiedenen Dateien zu organisieren und später wieder zusammen zu fügen…

1.) Den Quellcode in einen beliebigen ASCII-Texteditor eintippen und abspeichern.

2.) Den Quellcode mit einem Compiler übersetzen, wodurch eine Objektdatei (*.pbj oder *.o) erzeugt wird.

3.) Die Objektdatei mit einem Linker binden, so dass eine ausführbare Datei erzeugt wird. Der Linker sucht außerdem alle benötigten Funktionen aus den Standard-Bibliotheken heraus und fügt diese anschließend dem fertigen Programm hinzu.


zu 2.)

gcc -c primz_haupt.c
gcc -c primz_math.c

zu 3.)

gcc primz_haupt.o primz_math.o -lm -O3 -Wall -o primzahl


/*
primz_haupt.c
*/

#include <stdio.h>
#include "primz_math.h"

int main() {
        int zahl;

        for(zahl=1; zahl<=100; zahl++) {
                if (ist_primzahl(zahl)) {
                        printf("%d\n", zahl);
                }
        }
        return(0);
}
/*
primz_math.c
*/

#include <math.h>

int ist_primzahl(int zahl) {
        int teiler=2;

        while(teiler <= sqrt(zahl)) {
                if(zahl % teiler == 0) {
                        return(0);
                }
                teiler++;
        }
        return(1);
}


Um die zuvor beschriebene Prozedur zu beschleunigen, gibt es die sogenannten Makefiles, welche alle Informationen zum kompilieren enthalten und den Prozess somit automatisch durchführen können.

Als erstes ein ausführliches Beispiel:

# Makefile
#

#4.) 'primz_haupt.o' + 'primz_math.o' zusammenfuehren
primzahl:       primz_haupt.o primz_math.o
                gcc primz_haupt.o primz_math.o -lm -o primzahl

#3.) 'primz_haupt.o' erzeugen + 'primz_math.h' einfuegen
# Info: 'primz_math.h' ist die Verknuepfung zu 'primz_math.c'
primz_haupt.o:  primz_haupt.c primz_math.h
                gcc -c primz_haupt.c

#2.) 'primz_math.o' erzeugen
primz_math.o:   primz_haupt.c
                gcc -c primz_math.c

#1.) aufraeumen
clean: 
                rm -f primz_haupt.o prinz_math.o

Und hier die komprimierte Version: :-)

# Makefile2
#

TARGET  = primzahl
OBJECTS = primz_haupt.o primz_math.o
HEADERS = primz_math.h
LIBS    = -lm

$(TARGET):      $(OBJECTS)
                gcc $^ $(LIBS) -o $@

primz_%.o:      primz_%.c $(HEADERS)
                gcc -c $&lt; -o $@

clean: 
                rm -f $(OBJECTS)

C-Programm – Größe von Variablen

Mit diesem kleinem Programm kannst du dir die minimale und maximale Größe von Variablen ausgeben lassen. :-)

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
        printf("min. char-Wert          : %d\n", SCHAR_MIN);
        printf("max. char-Wert          : +%d\n", SCHAR_MAX);
        printf("min. unsigned-char      : 0\n");
        printf("max. unsigned-char      : %u\n\n", UCHAR_MAX);

        printf("min. short-Wert         : %d\n", SHRT_MIN);
        printf("max. short-Wert         : +%d\n", SHRT_MAX);
        printf("min. unsigned-short     : 0\n");
        printf("max. unsigned-short     : %u\n\n", USHRT_MAX);

        printf("min. int-Wert           : %d\n", INT_MIN);
        printf("max. int-Wert           : +%d\n", INT_MAX);
        printf("min. unsigned-int       : 0\n");
        printf("max. unsigned-int       : %u\n\n", UINT_MAX);

        printf("min. long-Wert          : %ld\n", LONG_MIN);
        printf("max. long-Wert          : +%ld\n", LONG_MAX);
        printf("min. unsigned-long      : 0\n");
        printf("max. unsigned-long      : %lu\n\n", ULONG_MAX);

        printf("min. long long-Wert     : %lld\n", LLONG_MIN);
        printf("max. long long-Wert     : +%lld\n", LLONG_MAX);
        printf("min. unsigned-llong     : 0\n");
        printf("max. unsigned-llong     : %llu\n\n", ULLONG_MAX);


        printf("min. float-Wert         : %f\n", FLT_MIN);
        printf("max. float-Wert         : +%f\n", FLT_MAX);
        printf("float Genauigkeit       : %d\n\n", FLT_DIG);

        printf("min. double-Wert        : %lf\n", DBL_MIN);
        printf("max. double-Wert        : +%lf\n", DBL_MAX);
        printf("double Genauigkeit      : %d\n\n", DBL_DIG);

        printf("min. long double        : %Lf\n", LDBL_MIN);
        printf("max. long double        : +%Lf\n", LDBL_MAX);
        printf("long double Genu.       : %d\n\n", LDBL_DIG);

        return 0;
}


Ausgabe:

min. char-Wert : -128
max. char-Wert : +127
min. unsigned-char : 0
max. unsigned-char : 255

min. short-Wert : -32768
max. short-Wert : +32767
min. unsigned-short : 0
max. unsigned-short : 65535

min. int-Wert : -2147483648
max. int-Wert : +2147483647
min. unsigned-int : 0
max. unsigned-int : 4294967295

min. long-Wert : -2147483648
max. long-Wert : +2147483647
min. unsigned-long : 0
max. unsigned-long : 4294967295

min. long long-Wert : -9223372036854775808
max. long long-Wert : +9223372036854775807
min. unsigned-llong : 0
max. unsigned-llong : 18446744073709551615

min. float-Wert : 0.000000
max. float-Wert : +340282346638528859811704183484516925440.000000
float Genauigkeit : 6

min. double-Wert : 0.000000
max. double-Wert : +179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889[…]

min. long double : 0.000000
max. long double : +1189731495357231765021263853030970205169063322294624200440323733891737005522970722616410290336528882853545697807495577314427443153670[…]


Wenn du das nächste C-Programm einmal kompiliert hast und es mehrere male nacheinander ausführst siehst du, dass die Variable ggf. an einer anderen Stelle im Speicher abgelegt wurde.

#include <stdio.h>

int main(void) {
        int var=0;
        printf("Die Adresse von var lautet: %p\n", &var);
        return 0;
}