Programmieren in C

von Prof. Dr. Rainer Thomas

Arrays

6.1 Eindimensionale Arrays
6.2 Zeichenketten (Strings)
6.3 Mehrdimensionale Arrays


6.1 Eindimensionale Arrays

Eindimensionale Arrays in C

Sieb des Eratosthenes

Programmbeispiel : Sieb des Eratosthenes

/* ------------------------------------------------------------------ */
/* Programm ERATO                                                     */
/* ------------------------------------------------------------------ */
/* Primzahlenermittlung mittels Sieb des Eratosthenes                 */
/* ------------------------------------------------------------------ */

#include <stdio.h>

#define SIZE     503
#define TRUE     1
#define FALSE    0
#define ANZZEIL  12
#define WRITELN  putchar('\n')

void main(void)
{
  int i,k;
  int iPrim, iAnzahl;
  char cFlags[SIZE+1];

  printf("\nPrimzahlen zwischen 3 und %d\n\n",2*SIZE+3);
  iAnzahl=0;
  for (i=0; i<=SIZE; i++)
    cFlags[i]=TRUE;
    for (i=0; i<=SIZE; i++)
      if (cFlags[i])
      { iPrim=i+i+3;
        for (k=i; k<=SIZE; k=k+iPrim)
          cFlags[k]=FALSE;
        iAnzahl++;
        printf("%6d",iPrim);
        if (iAnzahl%ANZZEIL == 0)
          WRITELN;
      }
}

/* ------------------------------------------------------------------ */
Bildschirmausgabe :

Programmbeispiel : Dezimal-Dualzahl-Umwandlung

/* ------------------------------------------------------------------ */
/* Programm DEZDUAL */
/* ------------------------------------------------------------------ */
/* Umwandlung einer positiven ganzen Dezimalzahl (unsigned Integer)   */
/* in eine Dualzahl                                                   */
/*                                                                    */
/* Staendige Division durch 2,                                        */
/* der anfallende Rest stellt jeweils die naechste Ziffer dar.        */
/* Anfallen der Ziffern von niedrigstwertiger zu hoechstwertiger      */
/* Stelle                                                             */
/* ------------------------------------------------------------------ */

#include <stdio.h>

#define BASIS    2
#define LAENGE   16
#define WRITELN  putchar('\n')

void main(void)
{
   char ziffern[LAENGE];
   unsigned zahl;
   int ziff_anz;
   printf("\npositive ganze Dezimalzahl ? ");
   scanf("%d",&zahl);
   ziff_anz=0;
   while (zahl)
   { ziffern[ziff_anz++]=zahl%BASIS+'0';
     zahl=zahl/BASIS;
   }
   printf("\numgewandelt in Dualzahl    : ");
   for (ziff_anz--; ziff_anz>=0; ziff_anz--)
      putchar(ziffern[ziff_anz]);
   WRITELN;
}

/* ------------------------------------------------------------------ */
Bildschirmausgabe :

Initialisierung von Arrays

Programmbeispiel zur Initialisierung von Arrays in C

/* ------------------------------------------------------------------ */
/* Programm INITAR1                                                   */
/* ------------------------------------------------------------------ */
/* Demonstration der Initialisierung von Arrays                       */
/* (hier: globale Arrays)                                             */
/* ------------------------------------------------------------------ */

#include <stdio.h>

#define ANZ 4

float a[]   ={3.5, -7.2, -4.3, 1.8};
float b[ANZ]={2.9, 1.3, 5.1};

void main(void)
{
  float c[ANZ];
  int i;
  void aus_array(float [], int);               /* Funktionsdeklaration */

  for (i=0; i<ANZ; i++)
    c[i]=a[i]+b[i];
    aus_array(c,ANZ);
}

void aus_array(float feld[], int laenge)       /* Funktionsdefinition */
{
  int i;

  printf("\n{ ");
  for (i=0; i<(laenge-1); i++)
    printf("%.2f, ",feld[i]);
  printf("%.2f }\n",feld[laenge-1]);
}

/* ------------------------------------------------------------------ */
Bildschirmausgabe :

6.2 Zeichenketten (Strings)

Zeichenketten (Strings) in C

Programmbeispiel zu Strings in C (1)

/* ------------------------------------------------------------------ */
/* Programm STRDEM1                                                   */
/* ------------------------------------------------------------------ */
/* Demonstrationsprogramm zu Zeichenketten (Strings)                  */
/* ------------------------------------------------------------------ */

#include <stdio.h>

#define NUL '\0'

char satz[]="Warum C ?";

void main(void)
{
  int i=0;
  printf("\n%s\n\n",satz);
  while (satz[i]!=NUL)
  { printf("%c =  %02x\n",satz[i],satz[i]);
    i++;
  }
  printf("  =  %02x\n",satz[i]);
}

/* ------------------------------------------------------------------ */
Bildschirmausgabe :

Programmbeispiel zu Strings in C (2)

/* ------------------------------------------------------------------ */
/* Programm STRDEM2                                                   */
/* ------------------------------------------------------------------ */
/* Demonstrationsprogramm zu Zeichenketten (Strings)                  */
/* ------------------------------------------------------------------ */

#include <stdio.h>

#define NUL   '\0'
#define MAXL  80

void main(void)
{
  char wort[MAXL+1];
  int i=0;
  printf("\nEingabestring ? ");
  scanf("%s",wort);              /* kein Adressoperator ! */
  printf("\n%s\n\n",wort);
  while(wort[i]!=NUL)
  { printf("%c =  %02x\n",wort[i],wort[i]);
    i++;
  }
  printf("  =  %02x\n",wort[i]);
}

/* ------------------------------------------------------------------ */
Bildschirmausgabe :

Programmbeispiel : Stringfunktionen (1)

/* ------------------------------------------------------------------- */
/* Programm STRDEM3                                                    */
/* ------------------------------------------------------------------- */
/* Demonstration selbstgeschriebener String-Funktionen                 */
/* Einlesen, Kopieren und Ermittlung der Laenge eines Strings          */
/* ------------------------------------------------------------------- */

#include <stdio.h>

#define NUL   '\0'
#define MAXL  80

int StrLang(char acKette[])                       /* Länge von acKette */
{
  int i=0;
  while (acKette[i] != NUL)
    i++;
  return(i);
}

void StrCopy(char acStr1[], char acStr2[])  /* Copy acStr1 nach acStr2 */
{
  int i=0;
  while ((acStr2[i]=acStr1[i])!=NUL)
    i++;
}

void main(void)
{
  char acEinString[MAXL+1],acAusString[MAXL+1];
  printf("\nEingabestring ? ");
  scanf("%s",acEinString);
  StrCopy(acEinString,acAusString);
  printf("\nAusgabestring = %s\n",acAusString);
  printf("Stringlaenge  = %d\n",StrLang(acEinString));
}

/* ------------------------------------------------------------------- */
Bildschirmausgabe :

Funktionen der ANSI-C-Standardbibliothek zur Stringbearbeitung (1)

/* -------------------------------------------------------------------- */
/*          strcpy          -         Kopieren eines Strings     */
/* -------------------------------------------------------------------- */

#include <string.h>       /* enthält Funktionsdeklaration */


char *strcpy(char *str1, const char *str2);
                       /* str1   String, in den kopiert wird (Zielstring) */
                       /* str2   String, der kopiert wird (Quellstring)   */
"strcpy" kopiert den String "str2" in den String "str1"
(genauer : an die Stelle, auf die durch "str1" gezeigt wird)
Funktionswert :
Pointer auf den Zielstring, d.h. "str1"

( = 1. Parameter )
/* -------------------------------------------------------------------- */
/*          strcat         -        Konkatenation zweier Strings */
/* -------------------------------------------------------------------- */

#include <string.h>       /* enthält Funktionsdeklaration  */

char *strcat(char *str1, const char *str2);
                       /* str1   String, an den angehängt wird */
                       /* str2   String, der angehängt wird    */


"strcat" hängt den String "str2" an den String "str1" an.
(der resultierende String "str1" wird mit dem '\0'-Zeichen abgeschlossen)

Funktionswert :
Pointer auf den resultierenden String, d.h. "str1"

( = 1. Parameter )
/* -------------------------------------------------------------------- */
/*          strcmp          -         Vergleich zweier Strings   */
/* -------------------------------------------------------------------- */

#include <string.h>       /* enthält Funktionsdeklaration    */

int strcmp(const char *str1, const char *str2);
                       /* str1   erster zu vergleichender String  */
                       /* str2   zweiter zu vergleichender String */
"strcmp" vergleicht den String "str1" lexikographisch mit dem String "str2".
Funktionswert :
< 0 , wenn "str1" kleiner "str2" ist
= 0 , wenn "str1" gleich "str2" ist
> 0 , wenn "str1" groesser "str2" ist
/* -------------------------------------------------------------------- */
/*        strchr -  Durchsuchen eines Strings nach einem Zeichen */
/* -------------------------------------------------------------------- */

#include <string.h>     /* enthält Funktionsdeklaration */

char *strchr(const char *str, int c);
                           /* str       zu durchsuchender String */
                           /* c         Suchzeichen              */
"strchr" durchsucht den String "str" nach dem ersten Auftreten des Zeichens "c"
Funktionswert :
Pointer auf die Stelle im String "str", an der das Zeichen %quot;c" erstmals auftritt,

bzw. NULL-Pointer, wenn das Zeichen %quot;c" nicht im String %quot;str" enthalten ist.
/* -------------------------------------------------------------------- */
/*  strstr - Durchsuchen eines Strings nach einem anderen String */
/* -------------------------------------------------------------------- */

#include <string.h>     /* enthält Funktionsdeklaration */

char *strstr(const char *str1, const char *str2);
                           /* str1     zu durchsuchender String */
                           /* str2     Suchstring               */
"strstr" durchsucht den String "str1" nach dem ersten Auftreten des Strings "str2"
Funktionswert :
Pointer auf die Stelle im String "str1", an das "string2" beginnt,

bzw. NULL-Pointer, wenn der String "str2" nicht im String "str1" enthalten ist.
/* -------------------------------------------------------------------- */
/*         strlen   -    Ermittlung der Länge eines Strings */
/* -------------------------------------------------------------------- */

#include <string.h>     /* enthält Funktionsdeklaration */

size_t strlen(const char *str);
                     /* str    String, dessen Länge ermittelt werden soll */
Anm:
Der Typ size_t ist der "natürliche" unsigned-Typ

(in <string.h> definiert)
"strlen" ermittelt die Länge des Strings "str" in Anzahl Zeichen (ohne abschließendes '\0'-Zeichen)
Funktionswert :
Länge des Strings "str" in Anzahl Zeichen

Programmbeispiel : Stringfunktionen (2)

/* ------------------------------------------------------------------ */
/* Programm STRDEM4                                                   */
/* ------------------------------------------------------------------ */
/* Demonstration von Stringfunktionen der ANSI-C-Standardbibliothek   */
/* Einlesen, Kopieren und Ermittlung der Laenge eines Strings         */
/* ------------------------------------------------------------------ */

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

#define NUL   '\0'
#define MAXL  80


void main(void)
{
  char acEinString[MAXL+1],acAusString[MAXL+1];
  printf("\nEingabestring ? ");
  scanf("%s",acEinString);
  strcpy(acAusString, acEinString);
  printf("\nAusgabestring = %s\n",acAusString);
  printf("Stringlaenge  = %d\n",strlen(acEinString));
}

/* ------------------------------------------------------------------ */
Bildschirmausgabe :

Funktionen der ANSI-C-Standardbibliothek zur Stringbearbeitung

(String-I/O-Funktionen)
/* -------------------------------------------------------------------- */
/*        sscanf      -      Formatierte "Eingabe" aus einem String     */
/*--------------------------------------------------------------------- */

#include <stdio.h>                /* enthält Funktionsdeklaration */

int sscanf(char *s, const char *ctrl, ...);

          /* s      String, aus dem "gelesen" wird                         */
          /* ctrl   String zur Festlegung des Eingabeformats               */
          /* ...    weitere Parameter:  Pointer auf Variable,              */
          /*                            die Eingabewerte aufnehmen sollen  */
"sscanf" entnimmt die naechsten Zeichen dem durch s referierten String, interpretiert sie entsprechend den im Steuerstring "ctrl" vorliegenden Typ- und Formatangaben und weist die demgemäss konvertierten Werte den durch ihre Pointer (weitere Parameter !) referierten Variablen zu.
Das Erreichen des String-Endes entspricht dem Erreichen des Dateiendes bei Dateien.
Funktionswert :
die Anzahl der erfolgreich zugewiesenen Werte
bzw. EOF (= -1), wenn - vor dem Konvertieren des ersten Wertes - ein Fehler aufgetreten ist.
Aufbau und Bedeutung des Steuerstrings "ctrl" wie bei der Funktion scanf.
 
 
/* -------------------------------------------------------------------- */
/*        sprintf      -      Formatierte "Ausgabe" in einen String     */
/*--------------------------------------------------------------------- */

#include <stdio.h>                /* enthält Funktionsdeklaration */

int sprintf(char *s, const char *ctrl, ...);

          /* s      String, in den die "Ausgabe" erfolgt                   */
          /* ctrl   String zur Festlegung des Ausgabeformats               */
          /* ...    weitere Parameter:  Ausgabewerte, Anzahl und Typ ent-  */
          /*                    sprechend Konvertierungszeichen in "ctrl"  */
"sprintf" legt die als weitere Parameter übergebenen Werte entsprechend den Formatangaben in "ctrl" als Zeichenfolgen in dem durch s referierten String ab. Die "Ausgabe" wird mit einem '\0'-Character abgeschlossen.
Funktionswert :
Anzahl der abgelegten Zeichen, ohne abschließenden '\0' -Character
Aufbau und Bedeutung des Steuerstrings "ctrl" wie bei der Funktion printf.
 
 

Programmbeispiel : formatierte Ein-/Ausgabe aus/in einen String

/* ------------------------------------------------------------------ */
/* Programm IO_STR                                                    */
/* ------------------------------------------------------------------ */
/* Beispiel zur formatierten "Ein-/Ausgabe" aus/in einen String       */
/* ------------------------------------------------------------------ */

#include <stdio.h>

#define ANZ  80

void main(void)
{
  char acZahlStr[ANZ+1];
  char acAusStr[ANZ+1];
  char acAusText[]="Produkt      :";
  int iZahl1, iZahl2;

  printf("\n2 int-Zahlen ? ");
  gets(acZahlStr);
  sscanf(acZahlStr, "%d%d", &iZahl1, &iZahl2);  /* "Eingabe" aus String */
  iZahl1=iZahl1*iZahl2;
  sprintf(acAusStr, "%s %d", acAusText, iZahl1); /* "Ausgabe" in String */
  puts(acAusStr);
}

/* ------------------------------------------------------------------ */
Bildschirmausgabe :

6.3 Mehrdimensionale Arrays

Mehrdimensionale Arrays in C

Programmbeispiel zu 2-dimensionalen Arrays : Matrixaddition

/* ------------------------------------------------------------------ */
/* Programm MATADD                                                    */
/* ------------------------------------------------------------------ */
/* Demonstrationsprogramm zu 2-dimensionalen Arrays                   */
/* Matrixaddition                                                     */
/* ------------------------------------------------------------------ */

#include <stdio.h>
#define ZEILEN 3
#define SPALTEN 4

float fmat1[][SPALTEN] = {{1.5,  4.1,  3.4, -4.0},
                          {2.2,    0, -3.7,  1.1},
                          {  0, -5.1,  6.6,  0.2}};
float fmat2[][SPALTEN] = {-1.5, 2.3, 3.7, 2.1, 0.7, 5.5, 3.3, 0,0,0,0,0};


void mat_add(float mat1[][SPALTEN],
             float mat2[][SPALTEN],
             float mat3[][SPALTEN], int anz_zeil)
{
  int i,j;

  for (i=0; i<anz_zeil; i++)
    for (j=0; j<SPALTEN; j++)
      mat3[i][j]=mat1[i][j]+mat2[i][j];
}

void mat_aus(float fmat[][SPALTEN], int anz_zeil)
{
  int i,j;

  for(i=0; i<anz_zeil; i++)
  { printf("\n{");
    for (j=0; j<SPALTEN; j++)
      printf("%6.2f, ",fmat[i][j]);
    putchar('}');
  }
  putchar('\n');
}

void main(void)
{
  float fmat3[ZEILEN][SPALTEN];

  mat_add(fmat1,fmat2,fmat3,ZEILEN);
  mat_aus(fmat3,ZEILEN);
}

/* ------------------------------------------------------------------ */
Bildschirmausgabe :
Zum Inhaltsverzeichnis Zum nächsten Abschnitt


Copyright © FH München, FB 04, Prof. Dr. Rainer Thomas
V - PC - 610 - 01 - TH - 05
V - PC - 610 - 02 - TH - 01
V - PC - 611 - 01 - TH - 03
V - PC - 611 - 02 - TH - 07
V - PC - 612 - 00 - TH - 05
V - PC - 613 - 00 - TH - 05
V - PC - 614 - 00 - TH - 07
V - PC - 620 - 00 - TH - 03
V - PC - 621 - 00 - TH - 04
V - PC - 622 - 00 - TH - 05
V - PC - 623 - 00 - TH - 06
V - PC - 624 - 01 - TH - 03
V - PC - 624 - 02 - TH - 05
V - PC - 624 - 03 - TH - 06
V - PC - 625 - 00 - TH - 03
V - PC - 626 - 00 - TH - 02
V - PC - 627 - 00 - TH - 02
V - PC - 630 - 00 - TH - 03
V - PC - 631 - 00 - TH - 03
V - PC - 632 - 00 - TH - 06