C-Programmierung

Seitenübersicht

Zur Seite "C-Sharp-Programmierung"

Zur Seite "Programmierung"

Zur Seite "UML"

Inhaltsverzeichnis

1 Compiler
2 Ausdrücke und Operatoren
3 Kontrollstrukturen
4 Beispiele
5 Arrays
6 Zeiger / Pointer
7 Strukturen
8 Schreiben/Lesen in Dateien
- 8.1 fopen, fprintf, fclose
- 8.2 Modus für »fopen()«
9 Syntax
10 MinGW
11 Troubleshooting
12 Quellen

Compiler

https://gcc.gnu.org

Unter Visual Studio sollte man folgendes Grundgerüst für C-Quelltexte verwenden:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

int main(void)
{
	setlocale(LC_ALL, "german");

...

	system("PAUSE");
}

Ausdrücke und Operatoren

https://de.wikibooks.org/wiki/C-Programmierung:_Ausdr%C3%BCcke_und_Operatoren

Programm mit arithmetischen Operatoren:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

void dez2bin_positiv(int zahl, char* array36)
{
    //Abschluss der Zeichenkette = '\0'
    array36[35] = '\0';
    for (int i = 34; i >= 0; i--)
    {
        if (i == 8 || i == 17 || i == 26)
        {
            array36[i] = ' ';
        }
        else
        {
            array36[i] = (zahl % 2) ? '1' : '0';
            zahl = zahl / 2;
        }
    }
}

void zweierkomplemen(char* array36)
{
    int pos = 0;
    for (int i = 34; i >= 0; i--)
    {
        if (i == 8 || i == 17 || i == 26)
        {
            array36[i] = ' ';
        }
        else
        {
            if (array36[i] == '0' && pos == 0)
                continue;
            if (array36[i] == '1' && pos == 0)
            {
                pos = 1;
                continue;
            }
            array36[i] = (array36[i] == '1') ? '0' : '1';
        }
    }
}

void dez2bin(int zahl)
{
    //Array für 32-Bit-Zahl
    //mit Leerzeichen nach 8 Bit und '\0' am Ende
    char d2b[36];
    int AZahl = zahl; //Zahl retten

    //Zahl binär darstellen
    if (zahl >= 0)
    {
        dez2bin_positiv(zahl, d2b);
    }
    else
    {
        //Zahl in positive Zahl umwandeln binär darstellen
        dez2bin_positiv(-zahl, d2b);
        //In negatibe Zahl binär umwandeln
        zweierkomplemen(d2b);
    }

    // Ausgabe der Zeichenkette
    printf("Zahl = %11i d  =  %s b\n", AZahl, d2b);
}

void und(void)
{
    int zahl1, zahl2, erg;
    printf("Zahl_1 = ");
    scanf("%i",&zahl1);
    printf("Zahl_2 = ");
    scanf("%i", &zahl2);
    erg = zahl1 & zahl2;
    dez2bin(zahl1);
    printf("                                         AND\n");
    dez2bin(zahl2);
    printf("--------------------------------------------------------------\n");
    dez2bin(erg);
}

void oder(void)
{
    int zahl1, zahl2, erg;
    printf("Zahl_1 = ");
    scanf("%i",&zahl1);
    printf("Zahl_2 = ");
    scanf("%i", &zahl2);
    erg = zahl1 | zahl2;
    dez2bin(zahl1);
    printf("                                         OR\n");
    dez2bin(zahl2);
    printf("--------------------------------------------------------------\n");
    dez2bin(erg);
}

void x_oder(void)
{
    int zahl1, zahl2, erg;
    printf("Zahl_1 = ");
    scanf("%i",&zahl1);
    printf("Zahl_2 = ");
    scanf("%i", &zahl2);
    erg = zahl1 ^ zahl2;
    dez2bin(zahl1);
    printf("                                         XOR\n");
    dez2bin(zahl2);
    printf("--------------------------------------------------------------\n");
    dez2bin(erg);
}

void nicht(void)
{
    int zahl1, erg;
    printf("Zahl_1 = ");
    scanf("%i",&zahl1);
    //printf("Zahl_2 = ");
    //scanf("%i", &zahl2);
    erg = ~zahl1;
    dez2bin(zahl1);
    printf("                                         NOT\n");
    //dez2bin(zahl2);
    printf("--------------------------------------------------------------\n");
    dez2bin(erg);
}

int main(void)
{
    setlocale(LC_ALL, "german");
    char oper;

    do
    {
        printf("Welcher Operator soll verwendet werden?\n");
        printf("a = AND\no = OR\nx = XOR\nn = NOT\n");
        printf("Ihre Auswahl: ");
        rewind(stdin);
        scanf("%c", &oper);
    } while (oper != 'a' && oper != 'o' && oper != 'x' && oper != 'n');

    switch (oper)
    {
    case 'a': und(); break;
    case 'o': oder(); break;
    case 'x': x_oder(); break;
    case 'n': nicht(); break;
    default: printf("Operation nicht möglich\n");
        break;
    }

}

Kontrollstrukturen

for-Schleife versus while-Schleife

Jede for-Schleife lässt sich durch eine while-Schleife formulieren und umgekehrt:

for-Schleife	entsprechende while-Schleife
for (ausdruck1; ausdruck2; ausdruck3) Schleifenanweisung	ausdruck1; while(ausdruck2) { Schleifenanweisung; ausdruck3; }

Folgende Anweisungen sind also gleichbedeutend:

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

int main(void){

int ival = 0;
int sum = 0;

while(ival <=  5){
    if(ival % 2)
        sum += ival;
    ival++;}
printf("sum = %d\n", sum);

    return 0;
}

und

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

int main(void){

int ival = 0;
int sum = 0;

for(ival= 0;ival <=  5;ival++){
    if(ival % 2)
        sum += ival;
}
printf("sum = %d\n", sum);

    return 0;
}

while-Schleife (kopfgesteuerte Schleife

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

int main(void){
    long c = 2;
    printf("N \tN^2 \tN^3 \n");
    while (c <= 1024) {
        printf("%ld", c);
        printf("%c", '\t');
        printf("%ld", (c*c));
        printf("%c", '\t');
        printf("%ld", c*c*c);
        printf("\n");
    c *= 2;
    }
    printf("\n");
    return 0;
}

for-Schleife (Zählschleife)

Hier wird die gleiche Ausgabe produziert wie mit obiger while-Schleife:

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

int main(void)
{

    long c;
    printf("N \tN^2 \tN^3 \n");
    for(c = 2; c <= 1024; c *= 2) {
        printf("%ld", c);
        printf("%c", '\t');
        printf("%ld", (c*c));
        printf("%c", '\t');
        printf("%ld", c*c*c);
        printf("\n");

    }
    printf("\n");
    return 0;
}

for-Schleife mit Komma-Operator

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

int main(void){


    for (int i = 0, j = 10; i < j; i++, j--) {
        printf("i = %i, j= %i\n", i, j);
       }
    //printf("\n");
    return 0;
}

Geschachtelte for-Schleife

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

int main(void){


    for (int i = 1; i < 5; i++) 
              for (int j = 1; j < 5; j++) 
        printf("%d * %d = %d\n", i, j, i * j);
       }
    //printf("\n");
    return 0;
}

Beispiele

Beispiel 01: printf

/* Datei: hello.c */ /*Dies ist ein Kommentar*/
/* Das Programm liegt in der Quelldatei hello.c*/

#include <stdio.h>
int main(void)
{
 printf ("Hello, world!\n");
 return 0; /*Bitte jetzt überlesen!*/

 }

Übergabe der Argumente argc, arg[v]:

#include<stdio.h>

int main(int argc, char* argv[]) {
    int i;
    printf("argc: %d\n", argc);
    for(i=0; i < argc; i++) {
        printf("argv[%d]: %s\n", i, argv[i]);
    }
    return 0;
}

Das erzeugte Programm produziert (unter Linux) folgende Ausgabe:

argc: 3
argv[0]: ./a.out
argv[1]: string1
argv[2]: string2

Beispiel 02: puts, scanf, if

/* Jedes Programm sollte mit einem Kommentar beginnen */

#include <stdio.h>

int main ()
{
	int stapel;
	puts("Geben Sie die Anzahl an Spielen ein:");
	scanf("%i", &stapel);
	if (stapel < 1) {
		puts ("Keine gültige Anzahl an Spielen!");
		return 1;
	}
	printf("Es gibt %i Karten\n", (stapel * 52));
	return 0;
}

getchar - putchar

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

int main()
{
	setlocale(LC_ALL, "german");
	//DEKLARATION
	char c;

	//while ((c = getchar()) != '.')
	//{
	//	putchar(c);
	//}

	// CR = 10
	//int CR_LF = 10;
	//while ((c = getchar()) != CR_LF)
	//{
	//	putchar(c);
	//}
	//char str_1[10] = "Adam";

	char vorname[20];
	int CR_LF = 10;

	printf("Vorname: ");
	//if (scanf("%19s", vorname) != 1){
	//	printf("Eingabefehler\n");
	//	return 1;
	//}
	//printf("Vorname: %s\n",vorname);
	//int i;
	//while ((c = getchar()) != CR_LF)
	//{
	//	vorname[i] = c;
	//	putchar(c);
	//	i++;
	//}
	//vorname[i] = '\0';
	int i;
	for (i = 0; (c = getchar()) != CR_LF; i++)
	{
		vorname[i] = c;
		putchar(c);
	}
	vorname[i] = '\0';

	printf("\n");

	for (i = 0; vorname[i] != '\0'; i++)
	{
		printf("%c", vorname[i]);
	}
	printf("\n");
	
	system("PAUSE");
}

Rückgabewert von scanf checken

/* scanf6.c */
#include <stdio.h>

int main(void) {
   char a;
   int b, check;

   printf("Bitte Eingabe machen (Zeichen/Zahl): ");
   check = scanf("%c %d",&a, &b);
   printf("check = %d \n",check);
   return 0;
}

Vokale tauschen

Version mit switch - case

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

int main(void)
{
	setlocale(LC_ALL, "german");

	char Vokale[] = "aeiouäöü";
	char Text[] = "Drei Chinesen mit dem Kontrabass.";

	int l_v = strlen(Vokale);
	int l_t = strlen(Text);

	for (int j = 0; j < l_v; j++)
	{

		for (int i = 0; i < l_t; i++)

		{
			switch (Text[i]){
			case 'a': Text[i] = Vokale[j];
			case 'e': Text[i] = Vokale[j];
			case 'i': Text[i] = Vokale[j];
			case 'o': Text[i] = Vokale[j];
			case 'u': Text[i] = Vokale[j];
			case 'ä': Text[i] = Vokale[j];
			case 'ö': Text[i] = Vokale[j];
			case 'ü': Text[i] = Vokale[j];
			}

		}

		printf("%s\n", Text);
	}

	//		system("PAUSE");
}

Version mit if

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>


void main(void)
{
	setlocale(LC_ALL, "german");

	char Vokale[] = "aeiou";
	int l_v = strlen(Vokale);
	char Text[] = "Drei Chinesen mit dem Kontrabass.";
	int l_t = strlen(Text);
	//int j = 0;

	for (int i = 0; i < l_v; i++){
	for (int j = 0; j < l_t; j++)
	{
		if (Text[j] == 'a' || Text[j] == 'e' || Text[j] == 'i' || Text[j] == 'o' || Text[j] == 'u')
		{
			Text[j] = Vokale[i];
		}

	}
	printf("%s\n", Text);
}
		
	system("PAUSE");
}

Rechenbeispiele

Fakultät

Fußgesteuerte Schleife do - while mit Dekrementierung:

//stdio.h - Bibliothek mit Funktionen für Ein- und Ausgabe
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//Garantiert die Ausgabe der deutschen Zeichen 
#include <locale.h>

// Start des Programms mit main()
//void - kein Eingabe oder Rückgabewert für BS
void main(void)
{
	setlocale(LC_ALL,"German");
	//Garantiert die Ausgabe der deutschen Zeichen 

	//DEKLARATION und INITIALISIERUNG
	int F;		//Fakultät-Zahl
	int Ergebnis = 1;
	int rf;		//Rettungsvariable
	//Auffoderung zur Eingabe
	printf("Geben Sie die positive Integer-Zahl ein: ");
	//Eingabe der Zahl mit scanf()
	//%i integer-Wert als Eingabe erwartet
	//&F - Adresse der Variable F
	scanf("%i",&F);
	rf = F;		//Eigabe retten
	//Jetzt folgt die Fußgestuerte Schleife
	do
	{
		//Teilberechnung des Ergebnises
		Ergebnis = Ergebnis * F;
		F--;	//F = F - 1 heßt F dekrementieren
	} while ( F > 0 );

	// Ausgabe des Ergebnises
	printf("Fakultät von %i beträgt %i.\n\n",rf,Ergebnis);
}

Funktion "Fakultät" in einem Programm für Lottozahlen mit for-Schleife und Inkrementierung:

/* bspl0034.c */
#include <stdio.h>

double fakultaet(int zahl) {
	int i;
	double ergebnis=1.0;
	for(i=1; i <= zahl; i++)
		ergebnis*=i;
	return(ergebnis);
}

main() {
	double ergebnis;
	ergebnis=fakultaet(49)/(fakultaet(43)*fakultaet(6));
	printf("\nDie Anzahl der moeglichen Kombinationen ");
	printf("im Lotto 6 aus 49 ist %.0f \n",ergebnis);
}

Taschenrechner

// kap010/listing010.c

#include <stdio.h>

#include <stdlib.h>



double addition( double x, double y ) {

  return (x + y);

}



double subtraktion( double x, double y ) {

  return (x - y);

}



double multiplikation( double x, double y ) {

  return (x * y);

}



double division( double x, double y ) {

  return (x / y);

}



double (*fptr[4])(double d1, double d2) = {

  addition, subtraktion, multiplikation, division

};



int main(void) {

  double v1=0.0, v2=0.0;

  int operator=-1;

  printf("Zahl1 :-> ");

  if( scanf("%lf", &v1) != 1 ) {

    printf("Fehler bei der Eingabe\n");

    return EXIT_FAILURE;

  }

  printf("Zahl2 :-> ");

  if( scanf("%lf", &v2)  != 1 ) {

    printf("Fehler bei der Eingabe\n");

    return EXIT_FAILURE;

  }

  printf("Welcher Operator soll verwendet werden?\n");

  printf("0 = +\n1 = -\n2 = *\n3 = /\n");

  printf("Ihre Auswahl: ");

  if( scanf("%d", &operator)  != 1 ) {

    printf("Fehler bei der Eingabe\n");

    return EXIT_FAILURE;

  }

  if( ! (operator >= 0 && operator <= 3) ) {

    printf("Fehler beim Operator\n");

    return EXIT_FAILURE;

  }

  printf("Ergebnis: %lf\n", fptr[operator](v1, v2));

  return EXIT_SUCCESS;

}

Euklid'scher Algorithmus (while-Schleife)

#include <stdio.h>

int main (void)
{
   int x = 24;
   int y = 9;

   while (x != y)
   {
      if (x < y)
         y = y - x;
      else
         x = x - y;
   }
   printf ("Der größte gemeinsame Teiler ist: %d\n", x);
   return 0;
}

... mit Abfrage von Zähler und Nenner:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <locale.h>
#include <stdlib.h>

int main(void)
{
    setlocale(LC_ALL, "German");
    //Initialisierung

    setlocale(LC_ALL, "German");
    //DEKLARATION:
    int Zaehler, Z, Nenner, N;
    //AUSGABE:
    printf("Geben Sie Zähler ein: ");
    do
    {
        //EINGABE:
        scanf("%i", &Zaehler);
    } while (Zaehler == 0);

    printf("Geben Sie Nenner ein: ");
    do
    {
        scanf("%i", &Nenner);
    } while (Nenner == 0);

    //Zaehler und Nenner retten
    Z = Zaehler;
    N = Nenner;

    //Betrag von Z und N
    Z = Z >= 0 ? Z : -Z;
    N = N >= 0 ? N : -N;

    while (Z != N)
    {
        if (Z > N)
            Z = Z - N;
        else
            N = N - Z;
    }

    // AUSGABE:
    printf("ggT von %i und %i ist %i.\n\n", Zaehler, Nenner, Z);

    system("PAUSE");
    return 0;
}

Zufallszahlen

Zufallszahl würfeln:

  #include <stdio.h>
  #include <stdlib.h>
  #include <time.h>

  void main(void)
  {
    int i;
    time_t t;

    time(&t);
    srand((unsigned int)t);              /* Zufallsgenerator initialisieren */

    for ( i=0; i<20; i++ )
      printf("%d ", rand() % 6 + 1);     /* Wuerfeln */
    printf("\n");
  }

Die Verwendung von Datum/Uhrzeit zur Initialisierung des Generators führt dazu, dass die erzeugte Zahlenfolge "zufällig" wird.[1]

Primzahlen

#include <stdio.h>
 
main()
{
   int n, c;
 
   printf("Enter a number\n");
   scanf("%d", &n);
 
   if ( n == 2 )
      printf("Prime number.\n");
   else
   {
       for ( c = 2 ; c <= n - 1 ; c++ )
       {
           if ( n % c == 0 )
              break;
       }
       if ( c != n )
          printf("Not prime.\n");
       else
          printf("Prime number.\n");
   }
   return 0;
}

[2]

Sieb des Eratosthenes

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define max_prim 999

bool pr_feld[(max_prim + 1)];  //Array der zu überprüfenden Zahlen

int main(void)
{
    for (int i = 0; i <= max_prim; i++)
    {
        pr_feld[i] = false;
    }
    //Sieb des Eratosthenes
    for (int i = 2; i <= max_prim; i++)
    {
        if (!pr_feld[i])
        {
            printf("%4d\t", i);
            for (int j = 1; (j*i) <= max_prim; ++j)
            {
                if ((j*i) <= max_prim)
                    pr_feld[(j*i)] = true;
            }
        }
    }
    printf("beliebige Taste zum Beenden druecken...");
    getchar();
    return EXIT_SUCCESS;
}

Binärzahlen

Ausgabe mit for

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

int main(void)
{
	setlocale(LC_ALL, "german");

	//Array für 32-Bit-Zahl
	char Arr32Bit[33];
	Arr32Bit[32] = '\0';
	int Zahl = 17;

	int AZahl = Zahl; //Zahl retten
	
	//Schleife erstellt einzelne Bits(0,1) und
	//wandelt die in ASCII-Zeichen ('0','1') durch
	//Addition von 48 (ASCII-Wert für '0')
	for (int i = 31; i >= 0; i--)
	{
		Arr32Bit[i] = (Zahl % 2) + '0';
		Zahl = Zahl / 2;
	}
	// Ausgabe der Zeichenkette
	printf("Zahl = %i d  =  %s b\n", AZahl, Arr32Bit);
	
	printf("-----------------------------\n");
	
	Zahl = AZahl; //Zahl neu setzen
	int i_Arr32Bit[32];
	// Diese Schleife berechnet nur Bits (0,1)
	for (int i = 31; i >= 0; i--)
	{
		i_Arr32Bit[i] = Zahl % 2;
		Zahl = Zahl / 2;
	}

	printf("Zahl = %i d  =  ", AZahl);
	//Ausgabe von 0 oder 1 (Integer) erfolgt über Schleife
	for (int i = 0; i < 32; i++)
	{
		printf("%i",i_Arr32Bit[i]);
		//nach jede 8 Bits wird ein Leerzeichen ausgegeben 
		if (i % 8 == 7)
		{
			printf(" ");
		}
	}
	printf(" b\n");

	system("PAUSE");
}

Version mit Eingabe der Zahl und Bit-Gruppierung

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

int main(void)
{
    setlocale(LC_ALL, "german");

    printf("Geben Sie die Dezimalzahl ein: ");
    int Zahl;
    scanf("%i", &Zahl);

    //Array für 32-Bit-Zahl
    //mit Leerzeichen nach 8 Bit und '\0' am Ende
    char d2b[36];
    int AZahl = Zahl; //Zahl retten
    d2b[35] = '\0';

    for (int i = 34; i >= 0; i--)
    {
        if (i == 8 || i == 17 || i == 26)
        {
            d2b[i] = ' ';
        }
        else
        {
            d2b[i] = (Zahl % 2) ? '1' : '0';
            Zahl = Zahl / 2;
        }
    }
    // Ausgabe der Zeichenkette
    printf("Zahl = %i d  =  %s b\n", AZahl, d2b);


    system("PAUSE");
}

Arrays

Länge des Arrays

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>


void main()
{
	setlocale(LC_ALL, "german");

	//DEKLARATION
	int TAB[] = {2,4,3,6,5,7,8,2,7,2,3,4,5,6,8,9,9,0,1};
	int laenge;
	laenge = sizeof(TAB)/sizeof(int);

	printf("Länge der Tabelle TAB %d\n", laenge);
	system("PAUSE");
}

Strings verändern

Hier werden deutsche Sonderzeichen umschrieben (Umlaute, ß):

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>
#include <string.h>




int main()
{
    setlocale(LC_ALL, "german");
    //DEKLARATION
    char quelle[] = "Die süße Hündin aus Österreich läuft in die Höhle des Bären.";
    char ziel[1000];


    //length - Länge der Zeichenkette incl. '\0'
    int length = sizeof(quelle) / sizeof(char);


    for (int i = 0, j = 0; i < length; i++, j++)
    {
        switch (quelle[i])
        {
        case 'Ü': ziel[j++] = 'U'; ziel[j] = 'e';
            break;
        case 'ü': ziel[j++] = 'u'; ziel[j] = 'e';
            break;
        case 'Ö': ziel[j++] = 'O'; ziel[j] = 'e';
            break;
        case 'ö': ziel[j++] = 'o'; ziel[j] = 'e';
            break;
        case 'Ä': ziel[j++] = 'A'; ziel[j] = 'e';
            break;
        case 'ä': ziel[j++] = 'a'; ziel[j] = 'e';
            break;
        case 'ß': ziel[j++] = 's'; ziel[j] = 's';
            break;
        default: ziel[j] = quelle[i];
            break;
        }
    }



    printf("%s\n", ziel);


    printf("\n");
}

Bubble Sort

https://de.wikipedia.org/wiki/Bubblesort

Bubblesort mit for

1. Variante:

#include <stdio.h>

#define SIZE 6

int main()
{
    int bubble[] = { 95, 60, 6, 87, 50, 24 };
    int inner,outer,temp,x;

/* Stellt Original-Array dar */
    puts("Original Array:");
    for(x=0;x<SIZE;x++)
        printf("%d\t",bubble[x]);
    putchar('\n');

/* Bubblesort */
    for(outer=0;outer<SIZE-1;outer++)
    {
        for(inner=outer+1;inner<SIZE;inner++)
        {
            if(bubble[outer] > bubble[inner])
            {
                temp=bubble[outer];
                bubble[outer] = bubble[inner];
                bubble[inner] = temp;
            }
        }
    }

/* Stellt sortiertes Array dar */
    puts("Sorted Array:");
    for(x=0;x<SIZE;x++)
        printf("%d\t",bubble[x]);
    putchar('\n');
    return(0);
}

[3]

2. Variante:

/****************************************************
* "Eine praktische Einfüehrung in C"                *
* von Doina Logofatu, entwickler-press, 2008        *
* Copyright Doina Logofatu & entwickler-press.de    *
* www.algorithmen-und-problemloesungen.de           *
*****************************************************/

#include <stdio.h>

int main(){
  int i, j, n, a[100], aux;
  printf("Wie viele Zahlen? "); scanf("%d", &n);
  printf("Die Zahlen:\n");
  for(i=0; i<n; i++)
    scanf("%d", &a[i]);
  for(i=0; i<n-1; i++)
    for(j=i+1; j<n; j++)
      if(a[i]>a[j]) 
        {aux=a[i]; a[i]=a[j]; a[j]=aux;}
  printf("\nAusgabe:\n");
  for(i=0; i<n; i++) printf(" %d ", a[i]);
  return 0;
}

Bubblesort mit while

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

void tausche(int *a,int *b)
{
	int hilfe;
	hilfe = *a;
	*a = *b;
	*b = hilfe;
}

int main()
{
	setlocale(LC_ALL, "german");
	//DEKLARATION und INITIALISIERUNG:
	int Tabelle[10] = {2, 3, -6, 1, 8, -7, 9, 3, 1, 0};
	int	laenge = 10;
	int	tauschenJaNein = 1;
	int	j = 1;
	//Ausgabe:Tabelle unsortiert
	for (int i = 0; i < laenge; i++)
	{
		printf("%i ", Tabelle[i]);
	}
	printf("\n");

	while (tauschenJaNein == 1)
	{
		tauschenJaNein = 0;
		for (int i = 0; i < laenge - j; i++)
		{
			if (Tabelle[i] > Tabelle[i + 1])
			{
				tausche(&Tabelle[i], &Tabelle[i + 1]);
				tauschenJaNein = 1;
			}
		}
		j++;
	}

	for (int i = 0; i < laenge; i++)
	{
		printf("%i ", Tabelle[i]);
	}
	printf("\n");

	system("PAUSE");
}

Mehrdimensionale Arrays

Zweidimensionale Arrays an Funktionen übergeben

// kap009/listing006-md.c
#include <stdio.h>
#include <stdlib.h>
#define WOCHE 2
#define TAGE 7

void durchschnitt( int arr[][TAGE] ) {
  int durchs=0;
  for( int i=0; i < WOCHE; i++) {
    for( int j=0; j < TAGE; j++) {
      durchs+=arr[i][j];
    }
  }
  printf("Besucher in %d Tagen\n", WOCHE*TAGE);
  printf("Gesamt : %d\n", durchs);
  printf("Tagesschnitt: %d\n", durchs /(WOCHE*TAGE));
}

int main(void) {
  int besucher[WOCHE][TAGE];
  printf("Besucherzahlen eingeben\n\n");
  for(int i=0; i < WOCHE; i++) {
    for(int j=0; j < TAGE; j++) {
      printf("Woche %d, Tag %d: ", i+1, j+1);
      if( scanf("%d", &besucher[i][j]) != 1 ) {
        printf("Fehler bei der Eingabe\n");
        return EXIT_FAILURE;
      }
    }
  }
  durchschnitt( besucher );
  return EXIT_SUCCESS;
}

[4]

Zeiger / Pointer

Zeiger als Rückgabewert

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

int* ifget(void) {
	static int puffer[5];
	for (int i = 0; i<5; i++) {
		printf("Wert %d : ", i + 1);
		if (scanf("%d", &puffer[i]) != 1) {
			printf("Fehler bei der Eingabe\n");
			return EXIT_SUCCESS;
		}
	}
	return puffer;
}
void main()
{
	setlocale(LC_ALL, "german");

	//DEKLARATION
	int Index;
	int* iptr = ifget();
	printf("Folgende Werte wurden eingelesen\n");
	for (int i = 0; i < 5; i++) {
		printf("%d : %d\n", i + 1, *(iptr + i));
	}
	printf("-----------------\n");
	printf("Welche Position (0 bis 4) möchten Sie ändern? ");
	scanf("%d",&Index);
	printf("Geben Sie den Wert ein: ");
	scanf("%d", &iptr[Index]);
	for (int i = 0; i < 5; i++) {
		printf("%d : %d\n", i + 1, *(iptr + i));
	}

	system("PAUSE");
}

Zugriff auf Arrayelemente über Zeiger

// kap010/listing006.c
#include <stdio.h>
#include <stdlib.h>
#define MAX 5

int main(void) {
  int iarr[MAX] = { 12, 34, 56, 78, 90 };
  int *iptr = NULL;
  // iptr zeigt auf das erste Element von iarr
  iptr = iarr;

  printf("iarr[0] = %d\n", *iptr);
  printf("iarr[2] = %d\n", *(iptr+2));
  *(iptr+4) = 66;   // iarr[4] = 66
  *iptr = 99;       // iarr[0] = 99
  // Alle auf einmal durchlaufen (2 Möglichkeiten)
  int *iptr2 = iarr;  // iptr2 auf den Anfang von iarr
  for(int i=0; i < MAX; i++, iptr2++) {
    printf("iarr[%d] = %d /", i, *(iptr+i));
    printf(" %d\n", *iptr2);  // so geht es auch
  }
  return EXIT_SUCCESS;
}

Array und Zeiger als Funktionsparameter

// kap010/listing007.c
#include <stdio.h>
#include <stdlib.h>


void modArr(int *arr, size_t s) {
  for(size_t i=0; i<s; ++i) {
    arr[i]*=2;
  }
}

void printArr(const int *arr, size_t s) {
  for(size_t i=0; i<s; ++i) {
    printf("%d \n", arr[i]);
  }
  printf("\n");
}

int main(void) {
  int iarr[] = { 11, 22, 33, 44, 55 };
  modArr(iarr, sizeof(iarr)/sizeof(int));
  printArr(iarr, sizeof(iarr)/sizeof(int));
  return EXIT_SUCCESS;
}

Strukturen

//Übersetzt mit C++-Compiler
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

//typedef struct Person
typedef struct Person
{
	char Nachname[50];
	char Vorname[30];
	double Groesse;
	double Gehalt;
	int Kinder_Anzahl;
} Per;		//Globale Strukturvariablen - 
			//werden mit default Werten initialisiert 

void Gross(Per per)
{
	printf("%s \t%1.2lf\n",per.Nachname,per.Groesse);
}

void NameGehaltKinder(Per per)
{
	Per *per_ptr = &per;
	printf("%s \t%.2lf \t%i\n", per_ptr->Nachname, per_ptr->Gehalt, per_ptr->Kinder_Anzahl);
}

int main(void)
{
	setlocale(LC_ALL, "german");

	Per Maier = {	//Lokale Strukturvariable - //wird mit default Werten nicht initialisiert 
		"Maier",
		"Max",
		1.82,
		3050.30,
		2
	};
		
	Person Glocke = {
		"Glocke", "Jens",1.77,2500.40,3
	};
	
	Gross(Glocke);
	Gross(Maier);

	NameGehaltKinder(Glocke);
	NameGehaltKinder(Maier);

	system("PAUSE");
}

Schreiben/Lesen in Dateien

fopen, fprintf, fclose

#include <stdio.h>


int main()

{

   /* Deklaration eines Dateizeigers */

   FILE *fp;

   double preisFeld[3] = {1.25, 10.7, 1.15};

   int index;


   /* Datei öffnen zum Schreiben, mit Prüfung */

   fp = fopen("datei.txt", "w");

   if(fp == NULL)

   {

      printf("Dateifehler\n");

      return 1;

   }


   /* double-Werte in Datei schreiben */

   for(index = 0; index < 3; index++)

      fprintf(fp, "%.2f ", preisFeld[index]);


   /* Datei schließen */

   fclose(fp);	

   return 0;

}

[5]

Modus für »fopen()«

Tabelle in Openbook

Syntax

Kurzformen für Zuweisungsoperatoren

Zahl += 2; == == > Zahl = Zahl + 2;
Zahl -= 2; == == > Zahl = Zahl - 2;
Zahl *= 2; == == > Zahl = Zahl * 2;
Zahl /= 2; == == > Zahl = Zahl / 2;
Zahl %= 2; == == > Zahl = Zahl % 2;

Tauschen

temp = op1;
op1 = op2;
op2 = temp;

bzw. als Funktion:

void tausche(int *a,int *b)
{
	int hilfe;
	hilfe = *a;
	*a = *b;
	*b = hilfe;

reverse


int main()
{
   int n, reverse = 0;

   printf("Enter a number to reverse\n");
   scanf("%d", &n);

   while (n != 0)
   {
      reverse = reverse * 10;
      reverse = reverse + n%10;
      n       = n/10;
   }

   printf("Reverse of entered number is = %d\n", reverse);

   return 0;
}

MinGW

Minimalist GNU for Windows

http://www.mingw.org/

Damit der gcc-Compiler in allen Verzeichnissen ausgeführt werden kann, muss der Pfad mit den ausführbaren Dateien von MinGW (z. B. C:\MinGW\bin) der Umgebungsvariablen path hinzugefügt werden:

Strg-x > System > Computerschutz > Reiter "Erweitert" > Umgebungsvariablen

Beim Compilieren werden die temporären Dateien wieder gelöscht. Wenn diese bestehen bleiben sollen, verwendet man die Option -save-temps: gcc hello.c -save-temps -o hello.

Troubleshooting

Beim Compilieren mit

gcc test.c -o test

erscheint die Meldung

Nicht definierter Verweis auf `sqrt'

obwohl #include <math.h> im Kopf der Quelle steht.

Die Verlinkung zu math.h wird mit der Option -lm hergestellt.

gcc test.c -lm -o test

Quellen

C von Kopf bis Fuß

https://de.wikibooks.org/wiki/C-Programmierung

Download von MinGW und Code:Blocks |