2 Übungen | |
→ | 2.8 Übung 7 |
Theorie |
Aufgabe: Kopie in dynamisch alloziertem Speicher |
Machen Sie sich mit dynamischer Speicheranforderung vertraut, siehe Abschnitt Häufig auftretende Problemstellungen → Dynamische Speicherverwaltung.
/** @file ex058.c Beispielprogramm fuer dynamische Speicheranforderung.
*/
/* Copyright (C) 2014-2017 - HS Schmalkalden. All rights reserved. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
/** Ein geometrischer Punkt.
*/
typedef struct {
double x; /**< X-Koordinate. */
double y; /**< Y-Koordinate. */
} PUNKT;
/** Eine Linie.
*/
typedef struct {
PUNKT P0; /**< Anfangspunkt. */
PUNKT P1; /**< Endpunkt. */
} LINIE;
/** Rechteck.
*/
typedef struct {
double xmin; /**< Linker x-Wert. */
double xmax; /**< Rechter x-Wert. */
double ymin; /**< Unterer y-Wert. */
double ymax; /**< Oberer y-Wert. */
} RECHTECK;
/** Konstante Variable vom Typ Rechteck.
*/
static const RECHTECK test_re = { 0.0, 10.0, 0.0, 12.0 };
/** Feld mit mehreren Variablen vom Typ Linie.
Jede Linie besteht ihrerseits aus 2 Punkten.
Jeder dieser Punkte wiederum besteht aus x- und y-Wert.
*/
static const LINIE linien[] = {
{{ 1.0, 1.0 }, { 9.0, 9.0 }},
{{ 2.0, 11.0 }, { 7.0, 8.0 }},
{{ 4.0, 3.0 }, { 9.5, 9.3 }},
{{ -1.0, 2.0 }, { 10.5, 10.5 }},
{{ 8.5, 8.5 }, { 2.0, 2.0 }},
{{ 5.5, 6.5 }, { 7.5, 8.3 }},
{{ 3.0, 13.0 }, { 7.0, 13.5 }},
{{ 1.0, 9.8 }, { 8.0, 1.0 }},
{{ -3.0, 4.2 }, { 13.0, 4.4 }},
{{ 1.0, 2.0 }, { 3.0, 4.0 }}
};
/** Anzahl der Linien im Feld linien.
Zur Ermittelung der Anzahl wird die Gesamtgroesse der
Variable linien durch die Groesse des Typs dividiert.
*/
static const size_t anzahl_linien = sizeof(linien)/sizeof(LINIE);
int
main(void)
{
LINIE *pl = NULL; /* Zeiger auf aktuelle Linie */
LINIE *mycopy = NULL; /* Kopie noch nicht angelegt */
size_t i; /* Index aktuelle Linie */
int exitcode = 1; /* Noch kein Erfolg */
/* Speicher dynamisch anfordern, danach testen auf Erfolg. */
mycopy = (LINIE *)malloc(sizeof(???));
if(mycopy) {
/* Daten kopieren (linien nach mycopy) */
memcpy(???, ???, ???);
/* Erfolg, es koennen jetzt keine Fehler mehr auftreten */
exitcode = 0;
/* Werte vergroessern, Operator -> verwenden, pl jeweils erhoehen */
pl = mycopy;
for(i = 0; i < ???; i++) {
pl ??? P0 ??? x = 2.0 * pl ??? P0 ??? x;
pl ??? P0 ??? y = 2.0 * pl ??? P0 ??? y;
pl ??? P1 ??? x = 2.0 * pl ??? P1 ??? x;
pl ??? P1 ??? y = 2.0 * pl ??? P1 ??? y;
pl++;
}
/* Werte ausgeben, Index und Operator . verwenden */
pl = mycopy;
for(i = 0; i < ???; i++) {
printf("Anfangs-x: %lg\n", pl ??? i ??? ??? P0 ??? x);
printf("Anfangs-y: %lg\n", pl ??? i ??? ??? P0 ??? y);
printf("End-x: %lg\n", pl ??? i ??? ??? P1 ??? x);
printf("End-y: %lg\n\n", pl ??? i ??? ??? P1 ??? y);
}
/* Dynamischen Speicher wieder freigeben */
free(???);
mycopy = NULL;
}
else {
fprintf(stderr, "FEHLER: Nicht genuegend Speicher!\n");
fflush(stderr);
}
return exitcode;
}
/* vim: set ai sw=4 ts=4 expandtab : */
Das Programm ex058 soll eine Kopie des Feldes linien in
dynamisch alloziertem Speicher anlegen.
In dieser Kopie sollen alle Koordinatenwerte verdoppelt werden
(z.B. für ein Hineinzoomen in einer grafischen Ansicht).
Die Koordinatenwerte sind auszugeben.
Nehmen Sie die erforderlichen Korrekturen an ex058.c vor, erstellen und testen Sie das Programm ex058.