C++: Mehrere Funktionen Zugriff auf Variable

[Anfänger C++ (Gast)]

Ich hatte vor ein paar Tagen schon einmal eine ähnliche Frage gestellt. 
Für mich als C++ Anfänger nicht so leicht zu bewerkstelligen.

Szenario:
Ich verarbeite in einer Funktion1 eine bestimmte Variable und weise ihr 
einen Wert zu. Genau diese Variabe möchte ich mit dem in Funktion1 zu 
gewiesenen Wert in einer Funktion2 wieder nutzen. Ich habe jetzt einiges 
bzgl. globaler Variablen und call by Reference durchgelesen un einiges 
ausprobiert. Es hat jedoch nie richtig kompiliert. Vermutlich weil ich 
mit der richtigen Syntax nicht vertraut bin. Über ein richtiges Beispiel 
wäre ich dankbar.

Minimalbeispiel_

void funktion1()
{
 int x;
 x = 21;
}

void funktion2()
{
 int y;
 y = 2*x;  // <- hier soll x automatisch gleich 21 sein, 
// d.h.funktion1()muss natürlich vor funktion2() aufgerufen werden
}

Greetz

[Thomas E. (thomase)]

Anfänger C++ schrieb:
> Minimalbeispiel_
> void funktion1()
> {
>  int x;
>  x = 21;
> }
>
> void funktion2()
> {
>  int y;
>  y = 2*x;  // <- hier soll x automatisch gleich 21 sein,
> // d.h.funktion1()muss natürlich vor funktion2() aufgerufen werden
> }

Nicht VOR sondern VON.

int f1()
{
  int x = 21;
  return x;
}

void f2()
{
  int y = 2 * f1();
}

mfg.

[Marcel (Gast)]

int x;

Global definieren anstatt lokal in einer Funktion. Da kann man 
eigentlich nichts falsch machen. Wo gab es hier Syntaxfehler?

Oder

int funktion1()
{
 int x;
 x = 21;
 return x;
}

In funktion2 dann einfach funktion1 aufrufen und den Wert abholen.

Welche Lösung davon besser ist geht aus deinem Minimalbeispiel nicht 
hervor.

[guest (Gast)]

und was ist mit static?

[Marcel (Gast)]

guest schrieb:
> und was ist mit static?

static sorgt dafür, dass lokale Variablen auch nach dem beenden der 
Funktion im Speicher bleiben.

[Anfänger C++ (Gast)]

Ich würde gerne mehrere Variablen in Funktion1() nutzen. DIe Möglichkeit 
mit die Variable als Rückgabewert wiederzuverwenden liegt also auf Hand, 
fällt bei mir jedoch aus.

Wie genau funktioniert dies mit en globalen Variablen?
In etwa so?

unter.h
extern int x;
extern int y;
extern int z;
void funktion1();
void funktion2();

unter.c
void funktion1()
{
 x = 21;
 y = 13;
 z = 33;
}

void funktion2()
{
 int a,b,c;
 a = 2*x;  
 b = a + 2*y;
 c = z;
}

Irgendwoe ist da noch nen Fehler drin!

[Oliver S. (oliverso)]

Vielleicht wäre es jetzt Zeit für ein C-Buch. Das ++ kannst du getrost 
weglassen, deine Fragen haben C++ nix zu tun.

Oliver

[Cube_S (Gast)]

lass das "extern" weg und packe das

int x, y, z;

in "unter.c"

[C Plus Plus (Gast)]

C++ und globale Variablen machen keinen Sinn. Ein wichtiger Bestandteil 
von OOP ist die Datenkapselung. Man sollte daher nicht von Variablen 
sprechen, sondern von Objekten und Eigenschaften. Eigneschaften erreicht 
man nicht direkt.

[Cube_S (Gast)]

Man muss hier die Kirche im Dorf lassen. Auch bei objektorientierter 
Programmierung wird man um globale Variablen nicht immer herumkommen. Da 
heißen sie dann "ganz wichtigtuerisch" Singletons, sind aber im Prinzip 
nichts anderes als stinknormale globale Variablen.

Je nach Anwendung also absolut vertretbar.

[alter Hut (Gast)]

Cube_S schrieb:
> Auch bei objektorientierter
> Programmierung wird man um globale Variablen nicht immer herumkommen.

Dann hast du OOP nicht verstanden.

[Cube_S (Gast)]

alter Hut schrieb:
> Dann hast du OOP nicht verstanden.

Das halte ich für ein Gerücht

[Anfänger C++ (Gast)]

Cube_S schrieb:
> lass das "extern" weg und packe das
>
> int x, y, z;
>
> in "unter.c"

Das habe ich so versucht. Leider haben die Variablen in Funktion2 nicht 
den Wert, den ich Ihnen in Funktion1() zugewiesen habe.

Hab es debuggt.

Alternativen?

[Roland (Gast)]

Cube_S schrieb:
> ...GLobale Variablen...
>
> Je nach Anwendung also absolut vertretbar.

Nein. Globale Variablen sind nie vertretbar.

[Anfänger C++ (Gast)]

Ich wäre trotzdem für Anregungen für das Lösen meines Problems dankbar 
:)

[einfach mal die Antworten lesen (Gast)]

Deine C (und nicht C++) Frage wurde bereits beantwortet.

Entweder nimmst du die schlechte Lösung mit globalen Variablen oder 
nutzt Parameter und Rückgabe werte von Funktionen.

["Dr. Sommer" würde sagen (Gast)]

> Ich verarbeite in einer Funktion1 eine bestimmte Variable und weise ihr
> einen Wert zu. Genau diese Variabe möchte ich mit dem in Funktion1 zu
> gewiesenen Wert in einer Funktion2 wieder nutzen.

Entscheide dich erstmal, ob du C oder C++ programmieren möchtest !

Lösung in C:

f1() erzeugt ein Datum, gibt Datum via return zurück
f2() nimmt Datum von f1() als Parameter auf, führt Berechnung aus und 
gibt seinerseits Datum zur Ausgabe an ein printf zurück

Lösung in C++:

Baue dir eine Klasse K1, die ein Datum (eine private Membervariable) m1
und zwei öffentlichen Methoden f1(), f2() besitzt.
Instanziere ein Objekt dieser Klasse, dass nacheinander die Methoden 
f1() und f2() aufruft

f1() wirkt auf m1 ein
f2() wirkt auf m1 ein

Dann baust du dir noch eine Methode zur Ausgabe(), die als drittes 
aufgerufen wird.

[Cube_S (Gast)]

static int x, y, z;

void funktion1()
{
  x = 21;
  y = 13;
  z = 33;
}

void funktion2()
{
  int a, b, c;
  a = 2 * x;
  b = a + 2 * y;
  c = z;
}

Wenn es so nicht funktioniert, hat dein Compiler ein Problem. Das 
"static" ist nicht zwingend, macht die Variablen aber für andere 
c-Quelldateien beim linken "unsichtbar".

[Cube_S (Gast)]

Für diejenigen, die es unbedingt "objektorientiert" sehen wollen:

class A
{
private:
  int x, y, z;

public:
  void funktion1();
  void funktion2();
};

void A::funktion1()
{
  x = 21;
  y = 13;
  z = 33;
}

void A::funktion2()
{
  int a, b, c;
  a = 2 * x;
  b = a + 2 * y;
  c = z;
}

int main()
{
  A a;
  a.funktion1();
  a.funktion2();
  return 0;
}

Wobei ich die Kapselung alleine noch nicht als Objektorientierung 
bezeichnen würde. Dieser Begriff ist meiner Meinung nach erst dann 
wirklich gerechtfertigt wenn die "späte Bindung" ins Spiel kommt. Also 
mindestens zwei Klassen die von einander erben vorhanden sind und die 
Basisklasse eine virtuelle Funktion hat, die in der abgeleiteten Klasse 
überschrieben wird.

[Cube_S (Gast)]

Der Vollständigkeit halber noch "call by reference" im klassischen 
C-Stil

void funktion1(int *x, int *y, int *z)
{
  *x = 21;
  *y = 13;
  *z = 33;
}

void funktion2(int x, int y, int z)
{
  int a, b, c;
  a = 2 * x;
  b = a + 2 * y;
  c = z;
}

int main()
{
  int x, y, z;
  funktion1(&x, &y, &z);
  funktion2(x, y, z);
  return 0;
}

[Bastler (Gast)]

Anfänger C++ schrieb:
> Cube_S schrieb:
>> lass das "extern" weg und packe das
>>
>> int x, y, z;
>>
>> in "unter.c"
>
> Das habe ich so versucht. Leider haben die Variablen in Funktion2 nicht
> den Wert, den ich Ihnen in Funktion1() zugewiesen habe.
>
> Hab es debuggt.
>
> Alternativen?

Dir ist aber schon klar, daß Funktion1 erst mal gerufen werden muß, 
damit sie irgend einen Einfluß auf x,y,z haben kann, oder?

[Jan K. (jan_k)]

Hi Leute, ich habe ne frage zu dem letzten Beispiel (call by reference). 
Warum sollte man das so machen? Sehen und verändern können ja eh beide 
Funktionen die variablen. Auch ohne call by reference... Macht man das 
dann rein zu Übersichtzwecken?

Ich frage, weil ich ganz konkret vor einer Implementierung stehe, bei 
der ein Modul (eine C datei)  über ziemlich viele "lokale"  (static) 
variablen verfügt. Wäre schön ein ziemlicher Aufwand, die immer zu 
übergeben.  Dafür sieht man, was in welcher Funktion benötigt wird.
Oder ist es eh ratsam, ein neues typedef für das Modul zu machen, das 
eine struct ist, die alle lokalen Variablen enthält und dann in "c++ in 
c" Art, sprich manuelle Übergabe des "objektes" an die öffentlichen 
Funktionen zu machen?

Danke und schöne Grüße,
Jan

[Cube_S (Gast)]

Jan K. schrieb:
> Sehen und verändern können ja eh beide
> Funktionen die variablen. Auch ohne call by reference

Verändern kann in diesem Beispiel nur "funktion1". Ob man das so machen 
sollte ist eine andere Frage. Sobald die Parameterlisten ausarten ist 
schon zu überlegen ob diese Parameter von der Sache her nicht ein Objekt 
darstellen und die von Dir vorgeschlagene Lösung mit dem "struct" oder 
in C++ dann "class" nicht die bessere Variante ist.

[Karl H. (kbuchegg)]

Jan K. schrieb:
> Hi Leute, ich habe ne frage zu dem letzten Beispiel (call by reference).
> Warum sollte man das so machen?

Weil man im allgemeinen möglichstr wenig globale Variablen haben will. 
Bei kleinen µC muss bzw. wird man da ein wenig Abstriche machen, weil es 
da ein anderes Problem gibt. Auf den kleinen µC muss man den 
Speicherverbrauch in Summe im Auge behalten und das geht mit globalen 
Variablen am einfachsten.

Aber ansonsten will man zb für einfache und simple Standardaufgaben 
keine globalen Variablen haben, weil das Buchführen welcher Wert jetzt 
gerade in der globalen 'Interface' Variablen sitzt mühsam und 
fehleranfällig ist.

> Funktionen die variablen. Auch ohne call by reference... Macht man das
> dann rein zu Übersichtzwecken?

Du kriegst dann eine Funktion die auch wirklich in sich abgeschlossen 
ist und keine Nebeneffekte an irgendwelchen globalen Variablen hat. Die 
Funktion kann dann von jeder Stelle aus bedenkenlos aufgerufen werden. 
Sie macht ihr Ding, liefert ihre Werte und das wars.

> Ich frage, weil ich ganz konkret vor einer Implementierung stehe, bei
> der ein Modul (eine C datei)  über ziemlich viele "lokale"  (static)
> variablen verfügt.

Welches Modul?

>  Dafür sieht man, was in welcher Funktion benötigt wird.
> Oder ist es eh ratsam, ein neues typedef für das Modul zu machen, das
> eine struct ist, die alle lokalen Variablen enthält und dann in "c++ in
> c" Art, sprich manuelle Übergabe des "objektes" an die öffentlichen
> Funktionen zu machen?

Das kommt drauf an.
Wenn du das Gefühl hast, das es sich dabei um ein tatsächliches 'Objekt' 
handelt ... ja dann würde man das genau so machen.

Ein Stack beispielsweise, oder eine FIFO ist für sich genommen ein 
'Objekt' mit einer für sich alle vernünftigen Funktionalität. Zudem ist 
das etwas, das man immer wieder mal gebrauchen kann. D.h. in dem Fall 
würde man sehr wahrscheinlich die ganze Sache sauber machen und alle 
Variablen, die du jetzt als (static) modul-lokale globale Variablen 
eingeführt hast, in einer struct organisieren. Im Endeffekft ist das ja 
nichts anderes als eine andere Origanistation, in der um die (stativ) 
modul-lokalen Variablen eine Hülle gelegt wird und ihnen ein Name 
gegeben wird.

Das 'löst' dann gleich auch deine Bedenken wegen der langen 
Argumentlisten. Anstelle alle 'Variablen' einzeln zu übergeben, stellst 
du den Funktionen einen Pointer auf das Objekt zur Verfügung, mit denen 
sie arbeiten sollen. Und plötzlich ist es dann auch überhaupt kein 
Problem mehr, mit ein und demselben Satz von Funktionen nicht nur 1, 
sondern auch schon mal 4 derartige FIFO Objekte in einem Programm zu 
haben.