2 Übungen | |
→ | 2.8 Übung 7 |
Theorie |
Aufgabe 1: Sichtbarkeit von Variablen innerhalb eines Modules |
Aufgabe 2: Sichtbarkeit von Variablen bei mehreren Modulen |
Aufgabe 3: Persistente Variable |
Machen Sie sich mit der Sichtbarkeit von Variablen und den Speicherklassen "static" und "extern" vertraut, siehe Mehrere Quelltext-Module → Sichtbarkeit von Variablen und Funktionen.
Im Programm ex020.c ist beabsichtigt, dass alle Funktionen
dieselbe Variable x benutzen.
Korrigieren Sie den Quelltext, so dass das Programm ex020 erstellt
werden kann, erstellen und testen Sie das Programm!
/** @file ex020.c Beispielprogramm fuer Sichtbarkeit von Funktionen.
*/
/* Copyright (C) 2014-2017 - HS Schmalkalden. All rights reserved. */
#include <stdio.h>
void
f(void)
{
int i = 9;
x = i;
printf("Wert von x: %d\n", x);
}
static int x = 0;
void
g(void)
{
x = 27;
printf("Wert von x: %d\n", x);
}
int
main(void)
{
f();
g();
return 0;
}
/* vim: set ai sw=4 ts=4 expandtab : */
Das Program ex021 soll aus den zwei Quelltext-Modulen ex021a.c und ex021b.c erstellt werden.
Aus dem Modul ex021a.c wird die Funktion
ex021b_multiplikation() aufgerufen, die in ex021b.c
definiert ist. Der Prototyp der Funktion steht in der Header-Datei
ex021b.h.
Die Funktion soll das Ergebnis der Multiplikation in der Variable
ergebnis abspeichern, die in ex021a.c definiert ist.
Fügen Sie in ex021b.c eine entsprechende Deklaration der Variable
ein.
Erstellen und testen Sie das Programm!
/** @file ex021a.c Beispiel fuer moduluebergreifenen Zugriff auf Variablen.
*/
/* Copyright (C) 2014-2017 - HS Schmalkalden. All rights reserved. */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <limits.h>
#include "ex021b.h"
/** Ergebnis der Multiplikation.
*/
int ergebnis = 0;
/** Wert in int-Variable einlesen.
@param txt Text, der als Prompt-Zeichen ausgegeben wird, darf
NULL sein.
@param dptr Adresse der Variable, die gesetzt werden soll.
@return 1 bei Erfolg, 0 bei Fehlschlag.
*/
int
dataread_int(const char *txt, int *dptr);
/** Hauptprogramm.
@return 0 bei Erfolg, alle anderen Werte bedeuten Fehler.
*/
int
main(void)
{
int x = 0; /* Erster Faktor */
int y = 0; /* Zweiter Faktor */
if(dataread_int("Erster Faktor: ", &x)) {
if(dataread_int("Zweiter Faktor: ", &y)) {
ex021b_multiplikation(x, y);
printf("Ergebnis: %d\n", ergebnis);
}
}
return 0;
}
int
dataread_int(const char *txt, int *dptr)
{
char tl[64];
char *endptr;
char *testptr;
long value;
int back = 0;
if (NULL != dptr) {
if (NULL != txt) {
fputs(txt, stdout);
}
if (fgets(tl, sizeof(tl), stdin)) {
endptr = NULL;
errno = 0;
value = strtol(tl, &endptr, 10);
if (NULL != endptr) {
if (endptr == tl) {
fputs("Fehler, kein ganzzahliger Wert!\n", stderr);
}
else {
if ( (ERANGE == errno)
&& ((LONG_MIN == value) || (LONG_MAX == value))
) {
fputs("Fehler, Bereichsueberlauf!\n", stderr);
}
else {
if ((INT_MAX < value) || (INT_MIN > value)) {
fputs("Fehler, Bereichsueberlauf!\n", stderr);
}
else {
back = 1;
testptr = endptr;
while ('\0' != *testptr) {
switch (*testptr) {
case ' ': case '\t': case '\r': case '\n': {
} break;
default: {
back = 0;
} break;
}
testptr++;
}
if (1 == back) {
*dptr = value;
}
else {
fputs(
"Fehler, nicht verarbeitbarer Text am Ende",
stderr
);
fputs(
" der Eingabe: ",
stderr
);
fputs(endptr, stdout);
}
}
}
}
}
else {
*dptr = value;
back = 1;
}
}
}
return back;
}
/* vim: set ai sw=4 ts=4 expandtab : */
#ifndef EX021B_H_INCLUDED
#define EX021B_H_INCLUDED 1
#ifdef __cplusplus
extern "C" {
#endif
/** Multiplikation zweier ganzer Zahlen.
Das Ergebnis wird in der globalen Variable ergebnis gespeichert.
@param op1 Linker Faktor.
@param op2 Rechter Faktor.
*/
void
ex021b_multiplikation(int op1, int op2);
#ifdef __cplusplus
}
#endif
#endif
/* ifndef EX021B_H_INCLUDED */
/** @file ex021b.c Beispiel fuer moduluebergreifenen Zugriff auf Variablen.
*/
/* Copyright (C) 2014-2017 - HS Schmalkalden. All rights reserved. */
#include "ex021b.h"
void
ex021b_multiplikation(int op1, int op2)
{
ergebnis = op1 * op2;
}
/* vim: set ai sw=4 ts=4 expandtab : */
Erstellen Sie das Programm ex047 und führen Sie es aus.
Entfernen Sie das Schlüsselwort static vor der
Variablendefinition von wert in der Funktion
increment().
Erstellen Sie das Programm erneut und führen Sie es aus.
Wie ändert sich die Ausgabe des Programmes?
/** @file ex047.c Beispielprogramm fuer persistente Variable in Funktion.
*/
/* Copyright (C) 2014-2017 - HS Schmalkalden. All rights reserved. */
#include <stdio.h>
/** Funktionseigene Variable erhoehen und zurueckgeben.
@return Neuer Variablen-Wert.
*/
int increment(void);
int
main(void)
{
int i; /* Schleifenzaehler */
int k; /* Ergebnis von increment */
for(i = 10; i < 20; i++) {
k = increment();
printf("%d\n", k);
}
return 0;
}
int
increment(void)
{
static int wert = 125; /* Interne Variable der Funktion */
wert++;
return wert;
}
/* vim: set ai sw=4 ts=4 expandtab : */