C-Programmierung: Druckversion: Aufgaben

Aus Wikibooks
Wechseln zu: Navigation, Suche

Sinuswerte[Bearbeiten]

Aufgabenstellung[Bearbeiten]

Entwickeln Sie ein Programm, das Ihnen die Werte der Sinusfunktion in 10er Schritten von 0 bis 360° mit drei Stellen nach dem Komma ausgibt. Die Sinusfunktion sin() ist in der Header-Datei math.h definiert. Achten Sie auf eventuelle Typkonvertierungen.

Musterlösung[Bearbeiten]

Online-Compiler ideone

#include <stdio.h> 
#include <math.h>
 
int main(void)
{
    /* Konstante Pi definieren */
    const double Pi = 3.141592653;
	
    /* Variablen definieren */
    double winkel;
    double rad;
    double sinus;
    int i;
	
    printf("Programm zur Berechnung der Sinusfunktion in 10er Schritten\n");
    printf("Winkel   Sinus des Winkel\n");
 
    /* Schleife zur Berechnung der Sinuswerte */
    for (i = 0; i <= 36; i++)
    {
        winkel = 10 * i;         /* 10er Schritte berechnen */
		
        rad = winkel * Pi / 180; /* Berechnen des Bogenmaßwinkels */
        sinus = sin(rad);
 
        printf("%6g  %6.3f\n", winkel, sinus); /* tabellarische Ausgabe */
    }
	
    return 0;
}

Wir benutzen bei der Musterlösung drei Variablen:

  1. winkel für die Berechnung der Winkel in 10er Schritten,
  2. rad zur Berechnung des Bogenmaßes und
  3. sinus für den endgültigen Sinuswert.

In einer Schleife werden die Winkel und deren Sinuswerte nacheinander berechnet. Anschließend werden die Winkel tabellarisch ausgegeben.

Dreieck[Bearbeiten]

Aufgabenstellung[Bearbeiten]

Entwickeln Sie ein Programm, das ein auf der Spitze stehendes Dreieck mit Sternchen (*) auf dem Bildschirm in folgender Form ausgibt:

*******
 *****
  ***
   *

Durch eine manuelle Eingabe zu Beginn des Programmes muss festgelegt werden, aus wie vielen Zeilen das Dreieck aufgebaut werden soll. Anschließend muss überprüft werden, ob die Eingabe gültig ist. Ist das nicht der Fall, muss das Programm abgebrochen werden.

Zur Implementierung der Aufgabe werden neben Ein- und Ausgabe auch Schleifen benötigt.

Musterlösung[Bearbeiten]

Online-Compiler ideone

#include <stdio.h>

int main(void)
{
    /* Definition der Variablen */
    unsigned i, j, k;
    unsigned hoehe; /* Variable fuer die Dreieckshoehe */
    unsigned anzahlSterne, anzahlLeer; /* Variablen zur Speicherung von Sternen und Leerzeichen */

    // Eingabe der Dreieckshoehe
    printf("Programm zur Ausgabe eines auf der Spitze stehendes Dreiecks\n");
    printf("Bitte die Hoehe des Dreiecks eingeben: ");
	
    if ( scanf("%u", &hoehe)==0 ) /* Ist Eingabe gueltig? */
    {
        printf("Ungueltige Eingabe!\n");
        return 1;
    }
	
    /* Schleife zur Ausgabe */
    for (i = 1; i <= hoehe; i++)
    {
        /* Fuer jede neue Zeile die Anzahl der notwendigen Sterne und Leerzeichen ermitteln */
        anzahlLeer = i;
        anzahlSterne = (hoehe + 1 - i) * 2 - 1;
		
        printf("\n"); /* neue Zeile */

        for (j = 1; j <= anzahlLeer; j++)   /* Ausgabe der Leerzeichen */
            printf(" ");
        
        for (k = 1; k <= anzahlSterne; k++)	/* Ausgabe der Sterne */
            printf("*");

    }
	
    return 0;
}

Wir definieren zu Beginn drei Variablen:

  1. hoehe für die Anzahl der Zeilen über die sich das Dreieck erstreckt
  2. anzahlSterne für die Anzahl der Sterne in jeder Zeile
  3. anzahlLeer für die Anzahl der Leerzeichen in jeder Zeile.

Als Nächstes benötigen wir die Eingabe der Dreieckshöhe. Dazu wird über ein scanf() eine Zahl eingelesen und in der Variable hoehe gespeichert. Die Prüfung auf korrekte Eingabe übernimmt die Funktion scanf.

Ist die Eingabe gültig, kommen wir zur Hauptschleife (for). Diese wird für jede Zeile einmal abgearbeitet. Hier wird nun für jede Zeile die Anzahl der benötigten Sterne und Leerzeichen ermittelt. Jede Zeile beginnt mit Leerzeichen, weshalb diese zuerst mit einer for-Schleife ausgegeben werden. Darauf folgt eine weitere for-Schleife, welche die Anzahl der Sterne ausgibt. Am Ende der Hauptschleife erfolgt ein Zeilenumbruch.

Ist die Hauptschleife durchlaufen, wird das Programm erfolgreich beendet.

Vektoren[Bearbeiten]

Aufgabenstellung[Bearbeiten]

Entwickeln Sie ein Programm, das das Skalarprodukt zweier Vektoren bestimmt. Die Anzahl der Elemente und die Werte der Vektoren sind in der Eingabeschleife manuell einzugeben.

Überprüfen Sie, ob die Anzahl der Elemente die Maximalgröße der Vektoren überschreitet, und ermöglichen Sie ggf. eine Korrektur. Legen Sie die maximale Anzahl der Vektorelemente mit einer define-Anweisung durch den Präprozessor fest.

Skalarprodukt: A*B = a1*b1 + a2*b2 + a3*b3 + ... + an*bn

Musterlösung[Bearbeiten]

Online-Compiler ideone

#include <stdio.h>

int main (void)
{
    enum { DIMENSION=100 };  /* Konstante für max. Dimension beider Vektoren */
    int v1[DIMENSION],v2[DIMENSION];  /* Arrays für Vektor 1 und 2 */
    int anzahl;      /* Dimension der Vektoren */
    int index;       /* Zählwert der Arrays    */
    int produkt;     /* Produkt jedes Schleifendurchlaufs */
    int ergebnis;    /* Gesamtwert auf den Einzelprodukte aufaddiert werden */

    /* Programmüberschrift */
    printf("Skalarprodukt 2er beliebiger Vektoren berechnen\n\n");	 
		
    do
    {
        printf("Bitte Anzahl der Dimensionen angeben (1-%i):" ,DIMENSION);
        scanf("%i",&anzahl);  /* Einlesen des Wertes der Vektordimension */
        if (anzahl>DIMENSION || anzahl<1)  
        {
            printf("\n Eingabe uebersteigt max. Dimensionszahl\n\n");
        }
    }
    while (anzahl>DIMENSION || anzahl<1); /* bei fehlerhafter Eingabe erneuter Schleifendurchlauf */

    for(index=0; index<anzahl; index++)  /* Einleseschleife des ersten Vektors */
    {
        printf("Wert %i fuer vektor 1 eingeben: ",index+1);	
        scanf("%i",&v1[index]);
    }

    for(index=0; index<anzahl; index++)  /* Einleseschleife des zweiten Vektors */
    {
        printf("Wert %i fuer Vektor 2 eingeben: ",index+1);
        scanf("%i",&v2[index]);
    }

    /* Schleife zur Berechnung des Skalarproduktes */
    ergebnis = 0;
    for(index=0; index<anzahl; index++)
    {
        produkt=v1[index]*v2[index];  /* Einzelwerte addieren */
        ergebnis+=produkt;            /* Produkte zum Gesamtwert aufsummieren */
    }

    /* Ausgabe des Gesamtwertes des Skalarproduktes */
    printf("Das Skalarprodukt der Vektoren betraegt: %i\n",ergebnis);
	
    return 0;
}

Polygone[Bearbeiten]

Augabenstellung[Bearbeiten]

Geometrische Linien können stückweise gerade durch Polygonzüge approximiert werden. Eine Linie kann dann so durch eine Menge von Punkten beschrieben, die die Koordinaten der End- und Anfangspunkte der geradem Abschnitte darstellen. Die Punkte eines Polygonzuges sind in einem Array gespeichert, das die maximale Anzahl von N Elementen hat. N soll als symbolische Konstante verwendet werden. Jeder Punkt soll durch eine Strukturvariable, die die x- und y-Koordinaten als Komponenten hat, beschrieben werden. Eine Linie wird also durch einen Vektor, dessen Elemente Strukturen sind, beschrieben.

Entwickeln Sie ein Programm, dass folgende Funktionen beinhaltet.

  • Manuelle Eingabe der Punktkoordinaten eines Polygons.
  • Bestimmung der Länge des Polygons und Ausgabe des Wertes auf dem Bildschirm.
  • Tabellarische Ausgabe der Punktkoordinaten eines Polygons auf dem Bildschrim.

Die Auswahl der Funktionen soll durch ein Menü erfolgen. Verwenden Sie dazu die switch-Konstruktion.

Musterlösung[Bearbeiten]

Online-Compiler ideone

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

enum { PUNKTE = 100 };  /* Definieren einer Konstanten */

typedef struct /* Definieren der Struktur POLYGON */
{
    int  x; /* koordinate x */
    int  y; /* koordinate y */
} POLYGON;

/* Funktions-Prototypen */
int einlesen( POLYGON p[PUNKTE] );		
void ausgabe (int anzahlpunkte,POLYGON p[PUNKTE]);
double berechnung (int anzahlpunkte, POLYGON p[PUNKTE] );

int main (void)
{
    POLYGON p[PUNKTE];
    int anzahlpunkte;
    int menuezahl;
	
    puts("Dies ist ein Programm zur Berechnung eines Polygonzuges");
    do
    {
        /* Eingabe menue */
        printf("*********************************************************\n");
        printf("*  Sie haben folgende Moeglichkeiten:\t\t\t*\n");
        printf("*  1: Eingabe von Werten zur Berechnung des Polygones\t*\n");
        printf("*  2: Ausgabe der eingegebenen Werte in Tabellenform\t*\n");
        printf("*  3: Berechnen des Polygonzuges\t\t\t*\n");
        printf("*  4: Beenden des Programmes\t\t\t\t*\n");
        printf("*  Bitte geben sie eine Zahl ein!\t\t\t*\n");
        printf("*********************************************************\n");
        scanf("%d",&menuezahl);

        switch(menuezahl)
        {
        case 1:	/* Funktionsaufruf: Einlesen der Punktkoordinaten  */
            anzahlpunkte = einlesen( p );
            break;

        case 2:	/* Funktionsaufruf: Ausgabe der eingelesenen Werte */
            ausgabe(anzahlpunkte,p);
            break;
			
        case 3:	/* Funktionsaufruf: Berechnung des Polygonzuges */
		
            printf("der eingegebene Polygonzug ist %f lang.\n\n",berechnung (anzahlpunkte,p));		
            break;

        case 4:	 /* Beenden der Funktion */
            printf("Auf Wiedersehen, benutzen sie dieses Programm bald wieder!\n\n");
            break;

        default:  /* bei falscher Eingabe */
            puts("Ihrer Eingabe konnte kein Menüpunkt zugeordnet werden!\n"\
                 "Bitte versuchen sie es erneut.");
			
        }
    }
    while( menuezahl!=4 ); /* Ende der Schleife bei Eingabe der Zahl 4 */
	
    return 0;
}

int einlesen( POLYGON p[PUNKTE] )
{
    int zeile;
    int anzahlpunkte;

    do
    {
        printf("Bitte geben sie die Anzahl der Punkte des Polygons ein.\n"\
               "Bitte beachten sie, dass es min. 2 Punkte aber max. %i Punkte sein müssen!",PUNKTE);
        scanf("%d",&anzahlpunkte);
		
        if (anzahlpunkte<2 || anzahlpunkte>PUNKTE)
            puts("falsche eingabe!");
		
    }
    while(anzahlpunkte<2 || anzahlpunkte>PUNKTE);
	
    for (zeile=0;zeile<anzahlpunkte;zeile++)
    {
        printf(" wert %d fuer x eingeben:",zeile+1);
        scanf("%d",&p[zeile].x);
        printf( " wert %d fuer y eingeben:",zeile+1);
        scanf("%d",&p[zeile].y);
    }
    puts("");
    
    return anzahlpunkte;
}

/* Funktion zur Ausgabe der eingelesenen Punkte */
void ausgabe (int anzahlpunkte,POLYGON p[PUNKTE] )
{
    int zeile;
	
    puts("Anzahl\t|   x werte \t|   y werte\n");
    /* Schleife zum Auslesen der Struktur und Ausgabe der Tabelle */
    for (zeile=0;zeile<anzahlpunkte;zeile++)	
    {
        printf(" %5d\t|\t",zeile+1);
        printf(" %5d\t|\t",p[zeile].x);
        printf(" %5d\n",p[zeile].y);
    }
    puts("");
}

/* Funktion zum Berechnen des Polygons aus den eingelesenen Werten */
double berechnung (int anzahlpunkte, POLYGON p[PUNKTE])
{
    double ergebnis;
    int zeile;

    ergebnis=0;
    /* Schleife zum Auslesen und Berechnen der Punkte */
    for (zeile=0;zeile<anzahlpunkte-1;zeile++)  
    {
    	/* pow(x,y) x^y */
        ergebnis += sqrt(pow(p[zeile].x - p[zeile+1].x,2) + pow(p[zeile+1].y - p[zeile].y,2));
    }
    return ergebnis;	
}

Letztes Zeichen finden[Bearbeiten]

Aufgabenstellung[Bearbeiten]

Schreiben Sie eine Funktion, die feststellt, an welcher Stelle einer Zeichenkette ein Buchstabe das letzte Mal vorkommt. Als Parameter für die Funktion soll ein Zeiger auf den Anfang der Zeichenkette und das zu suchende Zeichen übergeben werden. Die Stellennummer, an der das Zeichen das letzte Mal vorkommt, ist der Rückgabewert. Ist das Zeichen nicht vorhanden oder wird ein Nullpointer an die Funktion übergeben, soll der Wert -1 geliefert werden. Testen Sie die Funktion in einem kurzen Hauptprogramm.
Hinweis: Die Funktion strrchr aus der Standardbibliothek übernimmt die gleiche Aufgabe.

Musterlösung[Bearbeiten]

Online-Compiler ideone

#include <stdio.h>

int position(char *zeichenkette, char zeichen); /* Prototyp der Suchfunktion */

int main(void)
{
    enum { LAENGE = 100 };
    int position_zeichen,start,c;
    char zeichen, zeichenkette[LAENGE];
    
    puts("Das ist ein Programm zum Vergleich einer Zeichenkette mit einem Zeichen");

    printf("Bitte Zeichenkette mit maximal %d Zeichen eingeben: ",LAENGE-1);
    // Einlesen einer beliebigen Zeichenkette mit Sonderzeichen
    for(start=0;(start<LAENGE-1) && ((c=getchar()) != EOF) &&c!='\n' ;start++)
    {
        zeichenkette[start]=c;
    }
    zeichenkette[start] = '\0'; /* String-Ende markieren */
	
    if(start==LAENGE-1) /* Wenn zu viele Zeichen sind, hier verarbeiten */
    {
        while(getchar()!='\n'); /* Zeichen solange einlesen bis Enter */
    }
	
    printf("Bitte ein Zeichen eingeben:");

    scanf("%c",&zeichen);  /* Einlesen des gesuchten Zeichens */	

    position_zeichen = position(zeichenkette,zeichen);
	
    if (position_zeichen == -1)	/* ist das Zeichen nich vorhanden? */
        puts("Eingegebenes Zeichen ist nicht in der Zeichenkette enthalten!");
    else
        /* wenn ja, Ausgabe des Suchergebnisses */
        printf("Position des letzten %c ist an Stelle: %d\n", zeichen, position_zeichen+1);
	
    return 0;
}

/* Funktion zum Suchen des Zeichens */
int position(char *zeichenkette, char zeichen)
{
    int back = -1, i;	
	
    if(zeichenkette!=NULL) /* Wenn keine Zeichen vorhanden sind, Rückgabe von 0 */
    {	
        /* Schleife zum Durchgehen der Zeichenkette */
        for(i = 0; zeichenkette[i] != '\0'; i++) 
        {
        	/* Kontrollausgabe der Zeichen mit der zugewiesenen Positionszahl */
            printf("An Stelle %4d steht das Zeichen  = %c\n",i+1,zeichenkette[i]);
            
            /* Vergleich der einzelnen Zeichen mit dem gesuchten */
            if (zeichenkette[i] == zeichen)  
            {
                back = i; /* Position des gesuchten Zeichens speichern */
            }
        }
    }
    return back;	/* Rückgabe der Position des gesuchten Zeichens */
}

Zeichenketten vergleichen[Bearbeiten]

Aufgabenstellung[Bearbeiten]

Schreiben Sie ein Programm, das zwei eingelesene Zeichenketten miteinander vergleicht. Die Eingabe der Zeichenketten soll durch eine Schleife mit Einzelzeicheneingabe realisiert werden. Als Ergebnis sollen die Zeichenketten in lexikalisch richtiger Reihenfolge ausgegeben werden. Beide Zeichenketten sollen über Zeiger im Hauptspeicher zugänglich sein.

Verwenden Sie für die Eingabe einer Zeichenkette einen dynamischen Zwischenpuffer. Nach Beendigung der Zeichenketteneingabe in diesen Puffer soll der notwendige Speicherplatz angefordert werden und die Zeichenkette in den bereitgestellten freien Speicherplatz übertragen werden.

Hinweis: Informieren Sie sich über den Gebrauch der Funktionen malloc() und free().

Musterlösung[Bearbeiten]

Online-Compiler ideone

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

char* einlesen(int);
int charsort(const void*,const void*);

int main (void)
{
    enum { LAENGE = 5 };
	
    char *z1;
    char *z2;

    printf("In diesem Programm koennen Sie 2 kleingeschriebene Zeichenketten mit jeweils\n"\
           "maximal %d Zeichen lexikalisch sortieren lassen.\n",LAENGE-1);		
		
    z1 = einlesen(LAENGE);
		
    if (z1==NULL)
    {
        puts("\n\nEs konnte kein ausreichender Speicher zur Verfuegung gestellt werden.\n"\
             "Das Programm wird beendet.");
        return 1;
    }
	
    z2 = einlesen(LAENGE);
		
    if (z2==NULL)
    {
        puts("\n\nEs konnte kein ausreichender Speicher zur Verfuegung gestellt werden.\n"\
             "Das Programm wird beendet.");
        free(z1);
        return 1;
    }
		
    puts("\nDie eingegebene Reihenfolge lautet:");
    puts(z1);
    puts(z2);

    /* Sortieren der Zeichenketten lexikalisch */
    qsort(z1, strlen(z1), 1, charsort);
    qsort(z2, strlen(z2), 1, charsort);
        
    puts("\nDie sortierte Reihenfolge lautet:");
    puts(z1);
    puts(z2);
        
    if( strcmp(z1,z2)==0 )
    {
    	puts("\nDie beiden Zeichenkette sind gleich.");
    }
    else
    {
    	puts("\nDie beiden Zeichenkette sind ungleich.");
    }
        
    free(z1);  /* Freigeben des Speicherplatzes */
    free(z2);  /* Freigeben des Speicherplatzes */

    return 0; 
}

char* einlesen(int maxlaenge) 
{
    char *zeichenkette = malloc(maxlaenge);
    
    if( zeichenkette!=NULL )
    {
    	int c, start;
    	printf("Bitte geben sie eine Zeichenkette mit maximal %d Zeichen ein: ",maxlaenge-1);
    
    	/* Einlesen einer beliebigen Zeichenkette mit Sonderzeichen ohne <ENTER> */
    	for(start=0; (start<maxlaenge-1) && (((c=getchar()) != EOF) && c!='\n') ;start++)
    	{
        	zeichenkette[start]=c;
    	}
    	if( start == maxlaenge-1 )
    	{
    	    while( ((c=getchar()) != EOF) && c!='\n' );
    	}
    
    	/* Hinzufügen eines Nullbytes an die letzte Stelle */
    	zeichenkette[start] = '\0';
    }

    return zeichenkette;
}

int charsort(const void *a,const void *b)
{
    const char *x = a, *y = b;
    if( *x < *y )
        return -1;
    else
    if( *x > *y )
        return 1;
    else
        return 0;
}

Messdaten[Bearbeiten]

Aufgabenstellung[Bearbeiten]

Schreiben Sie ein Programm, das eine Messdatendatei, die Strom- und Spannungswerte enthält, ausliest und daraus folgende Kennwerte für jede Größe berechnet:

  • Minimal- und Maximalwert,
  • Gleichanteil (linearer Mittelwert),
  • Effektivwert (geometrischer Mittelwert),

Der Name der Datei soll als Kommandozeilenargument übergeben werden. Über die Angabe einer Option in der Kommandozeile sollen nur die Messdaten auf dem Bildschirm ausgegeben werden. Aufrufbeispiele für das Programm sind

  • Berechnung und Ausgabe der Kennwerte: Aufgabe07.exe messdaten.txt
  • Ausgabe der Messdatenpaare: Aufgabe07.exe messdaten.txt -print

Vor der Berechnung oder Ausgabe sollen alle Messwerte eingelesen werden. Auf die Daten soll über ein Array von Zeigern, die auf jeweils ein Messdatenpaar verweisen angesprochen werden. Nach dem letzten Datenpaar soll das nachfolgende Element ein Null-Pointer sein, um das Ende zu markieren. Die Datenstruktur könnte zum Beispiel wie folgt definiert werden:

typedef struct
{
  double spannung, strom;
} Messwert;

Messwert *daten[MAX ANZAHL];

Die Berechnung und Ausgabe der Kennwerte auf dem Bildschirm soll in einer eigens definierten Funktion realisiert werden. Die Ausgabe der Messwerte soll ebenfalls durch eine Funktion erfolgen. Dabei sollen die Werte tabellarisch auf dem Bildschirm seitenweise ausgeben werden (pro Ausgabeseite 25 Zeilen). Folgende Fehlersituationen sind zu berücksichtigen:

  • Die Anzahl der Kommandozeilenargumente ist falsch.
  • Die Messdatendatei lässt sich nicht öffnen.
  • Beim Einlesen der Messdaten steht kein Speicherplatz mehr zur Verfügung.

Im Fehlerfall soll das Programm auf dem Bildschirm eine entsprechende Meldung ausgeben, ggf. bereitgestellten Speicher wieder freigeben und sich beenden.

Musterlösung[Bearbeiten]

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

/* Definition Typ Messwert */
typedef struct
{
  double spannung, strom;
} Messwert;

/* Funktions-Prototypen */
int  BerechnungAusgabe(Messwert *daten [], int start);
int  AusgabeMessdaten(Messwert *daten [], int start);
void speicherfreigabe(Messwert *daten [], int start);

int main(int argc, char *argv [])
{
  enum { MAX_ANZAHL = 700 };
  Messwert *daten[MAX_ANZAHL];    /* Array von Zeigern auf Messwert-Daten */
  FILE *fp;
  double sp, str;                 /* Hilfsvariablen Spannung, Strom*/
  int start;

  if (argc == 1)    /* Fehlerbehandlung */
  {
    fprintf(stderr, "Fehler: Geben Sie den Namen der Datei an, optional zzgl. [-print]");
    return 1;
  }

  fp = fopen(argv[1], "r");    /* Öffnen der Datei zum Lesen */

  if (fp == NULL)        /* wenn Datei nicht geöffnet werden konnte Fehlerhinweise und Ende */
  {
    fprintf(stderr, "\nFehler beim Oeffnen der Datei %s\n", argv[1]);
    return 2;
  }

  if (argc == 3)        /* Fehlerbehandlung des optionalen 2. Parameters */
  if (strcmp(argv[2], "-print") != 0)
  {
    fprintf(stderr, "\n\nder Parameter %s ist falsch", argv[2]);
    fclose(fp);
    return 3;
  }

  printf("\nDatei %s wurde zum Lesen geoeffnet!\n\n", argv[1]);

  /*
     paarweises Einlesen der Werte
     Abbruch wenn Grenze MAX_ANZAHL erreicht oder keine 2 Messwerte durch ';' getrennt zusammen gelesen werden konnten
     */
  for (start = 0; start < MAX_ANZAHL - 1 && fscanf(fp, "%lf;%lf", &str, &sp) == 2; start++)
  {
    /* Speicherplatz für Daten anfordern */
    if ((daten[start] = malloc(sizeof (Messwert))) == NULL)
    {
      fprintf(stderr, "Kein freier Speicher vorhanden.\n");
      fclose(fp);
      speicherfreigabe(daten, start);
      return 4;
    }

    /* Kopieren der Daten aus den Hilfsvariablen in den Speicher, auf die der Zeiger aktuell zeigt */
    daten[start]->strom = str;
    daten[start]->spannung = sp;
  }

  /* Datei schließen */
  fclose(fp);

  switch (argc) /* Fallunterscheidung zwischen Berechnen und Ausgaben der Reihe */
  {
  case 2:  BerechnungAusgabe(daten, start);  break;

  case 3:  AusgabeMessdaten(daten, start);   break;

  default: printf("\nIhre Eingabe wurde nicht akzeptiert, eventuell wurden zu viele Parameter eingegeben.");  break;
  }

  speicherfreigabe(daten, start);

  return 0;
}


/*
  Funktion zum Ermitteln der benötigten Daten aus der Messreihe und Berechnung
  ============================================================================
  */

int BerechnungAusgabe(Messwert *daten [], int start)
{
  const double Pi = 3.141592653;
  int i;
  double max_strom, max_spannung, min_strom, min_spannung;
  double u_gleichricht, i_gleichricht, u_effektiv, i_effektiv;

  max_strom = 0;
  max_spannung = 0;
  min_strom = 0;
  min_spannung = 100000000;

  /* Suchen von Min- und Max-Werten */

  for (i = 0; i < start; i++)
  {
    if (max_strom < daten[i]->strom)
    {
      max_strom = daten[i]->strom;
    }

    if (max_spannung<daten[i]->spannung)
    {
      max_spannung = daten[i]->spannung;
    }
    if (min_strom>daten[i]->strom)
    {
      min_strom = daten[i]->strom;
    }
    if (min_spannung > daten[i]->spannung)
    {
      min_spannung = daten[i]->spannung;
    }
  }

  /* Berechnung der einzelnen Daten */
  /* ===============================================================================================*/
  /* Berechnen des Gleichrichtwertes */
  u_gleichricht = 2 / Pi*max_spannung;
  i_gleichricht = 2 / Pi*max_strom;


  /* Berechnen des Effektivwertes */
  u_effektiv = max_spannung / sqrt(2);

  i_effektiv = max_strom / sqrt(2);

  /* Ausgabe der berechneten werte */
  /*=============================================================================================== */

  printf("\n\nDie berechneten Werte fuer ihre Messdatenreihe lauten:");

  printf("\n\n==========================================");
  printf("\n \t\t||  Strom  ||  Spannung\t||");
  printf("\n==========================================");
  /* Ausgabe Minima, Maxima */
  printf("\n maxima\t\t|| %3.3f A || %3.3f V\t||", max_strom, max_spannung);
  printf("\n==========================================");
  printf("\n minima\t\t||%3.3f A || %3.3f V\t||", min_strom, min_spannung);
  printf("\n==========================================");
  /* Ausgabe der Effektivwerte */
  printf("\n Effektivwert\t|| %3.3f A || %3.3f V\t||", i_effektiv, u_effektiv);
  printf("\n==========================================");
  /* Ausgabe der Gleichrichtwerte */
  printf("\n Gleichrichtwert|| %3.3f A || %3.3f V\t||", i_gleichricht, u_gleichricht);
  printf("\n==========================================");

  return 0;
}

int AusgabeMessdaten(Messwert *daten [], int start)
{
  int i;

  printf("\n\tSpanung || Strom\n");

  for (i = 0; i < start; i++)
  {
    printf("%4d  %8.4f  || %8.4f\n", i, daten[i]->spannung, daten[i]->strom);
  }

  return 0;
}

void speicherfreigabe(Messwert *daten [], int start)
{
  int i;
  for (i = 0; i < start; i++)
  {
    free(daten[i]);
  }
}