Globale Variablen

[Woodstock]

Hallo,

mal wieder eine total blöde Frage. Wenn ich in einem Quelltext eine Anzahl an globalen Variablen definiert habe, und die jetzt in anderen Quelltxten (für das geleiche Programm) benutzen will, dann muss ich die Variablen dort auch global definieren, mit einem extern davor, oder?

Und wenn das so ist, wirkt sich das arbeiten mit diesen externen Variablen auf die nicht extern definierten aus, das heißt wenn ich ihren Wert in einer anderen Funktion als main verändern, sind sie danach auch in mein verändern?

Muss ich um so mit den Variablen zu arbeiten sie als Parameter der anderen Funktion übergeben?

Bine

[BlueSkyDW]

Wenn Du Variablen global veränderst, wirkt sich das nur innerhalb der main aus. Wenn Du lokale V. benutzt, sei es in Funktionen z.B. deklarierst Du Sie ja neu und weißt ihnen loak einen Wert zu. :eek:

[Woodstock]

Das heißt also, das wenn ich drei Funktionen habe, alle jeweils in einem eigenen Quelltext, und nehmen wir einfach mal an, main wäre Quelltext 1, A wäre Quelltext (bzw. Funktion) 2, B 3, und ich von main in A gehe, dort die Variable a verändere, von dort in B gehe, dann arbeite ich wieder mit dem Wert der Variable wie sie in main war?

Bine

[eax]

hallo,

ich wuerde es an deiner Stelle mit Parameterübergabe machen

eben als referenz(mit orig. wert)

int funktionsname(param);

oder so

int funktionsname(param);

es wird eine lokale kopie angelegt

MfG eax

<FONT COLOR="#a62a2a" SIZE="1">[ 16. Oktober 2001 14:37: Beitrag 1 mal editiert, zuletzt von eax ]</font>

[BlueSkyDW]

Eben. Entweder Du arbeitest mit Parameterübergabe, oder Du mußt in jeder Funktion die lokale V. wieder neu deklarieren.

In deinem Beispiel heißt das:

Nein, Du arbeitest in B nicht mit a aus der main, sondern mit einer lokal deklarierten

in der main:

{

int a, b;

a = 10, b = 20;

void funktion(int a, ;

wenn Du jetzt innerhalb der funktion cout a und b machst, dann kommt nicht wie bei Dir gedacht a = 10 und b = 20, sondern der Compiler wird mit einer Adresszugriffsverletzung auf Dich zukommen, da bisher in a und b willkürliche, nicht genauer definierte Werte stehen würden.

:eek:

[haddock]

Hi,

a)

was macht die Suche, kam kein post mehr-> alles klar ?

// diese Variable ist wirklich global, weil sie

// außerhalb jeder Funktion definiert wurde:

int a=1;

void main()

{

f1(); // lokales a, Ausgabe :32

cout << a << endl; // Ausgabe :1

f2(); // globales a, Ausgabe :7

cout << a << endl; // Ausgabe :7 denn globales a wurde verändert

}

void f1()

{

int a; // lokal, verdeckt globales a

a = 32;

cout << a << endl;

}

void f2()

{

extern int a;

a = 7;

cout << a << endl;

}

:eek: ************************************************ :eek:

Aber: lieber so nicht, Funktionen sollten sich nie auf etwas verlassen, was außerhalb vielleicht oder vielleicht nicht existiert. Die einzige Schnittstelle sollten die Parameterliste und der Rückgabewert sein, das macht Funktionen so schön portabel.

Weiter: Wenn Werte verändert werden, sollte das über den Rückgabewert geschehen, weil die Funktionsparameter als *Kopie* übergeben werde, d.h. es müßten Adressen übergeben werden, dafür sollte man sich mit Zeigern auskennen...

Und: wenn mehrere Werte verändert werden sollen, kann man sich mit einem struct behelfen.

<FONT COLOR="#a62a2a" SIZE="1">[ 16. Oktober 2001 15:27: Beitrag 3 mal editiert, zuletzt von captain haddock ]</font>

[Woodstock]

Ich habe in meinem Quelltext von die Funktion main steht alle Variablen die ich benutze global definiert. In der Funktion main gehe ich in die Funktion YX, welche in einem anderen Quelltext steht. Dort habe ich die Variablen die ich in XY brauche extern global definiert, und das was er mit den Variablen tut, das ist dann auch im weiteren Verlauf von main gültig, nachdem XY beendet ist.

Klappt also...

Wie ich das mit Parameter-Übergabe machen könnte, weiß ich nicht. Kannst Du mir das sagen?

Stell Dir folgendes vor:

#include "Sabine(1).h"

void A();

FILE *fz, *fy;

char buffer2[1001]={NULL}, buffer3[1001]={NULL};

char Datei[100][1000], Liste[2][150], Eingabe[50][101];

char Ausgelesenes[50], Ausgelesenes1[1000][150]={NULL};

int j = 0, k = 0, c, b, d, i = 0, z = 0, g = 0, x = 0, h;

int scnt = 0, scnt2 = 0, pos = 0;

bool found;

void main()

{

.

.

.

else

{

A(??????);

}

.

.

.

Wenn ich jetzt in 'A' mit buffer2, Eingabe und scnt2 arbeiten will, wie muss ich das in die runden Klammern von A schreiben?

Bine

[haddock]

void A(char* my_buffer2, char** my_Eingabe, int& my_scnt2)

{

... // tu was

}

main()

{

...

A(buffer2, Eingabe, scnt2);

... // usw.

}

So sollte das gehen. Ich vermute, daß du einen C++-Compiler benutzt (sonst könntest du kein 'cout' verwenden ).

Mit einem C-Compiler geht das so nicht. Sag, Bienchen, hattest du schon mit Zeigern zu tun ? Ansonsten dürfte das so nicht ganz nachvollziehbar sein... :confused:

[Woodstock]

Ja, ich hatte schon mit Zeigern zu tun. Da weiß ich also auch, bzw. sollte ich wissen wie es funktioniert. (Braucht halt alles noch was Übung). Naja, ich denke schon das ich einen C++ Compiler benutzer, da ich ja C++ lernen soll (obwohl das bisher wohl eher noch C als C++ ist). Ich arbeite mit dem Visual Studio (von MS).

Ok, ich versuche das mal.

Also, wenn ich Dich richtig verstanden habe, dann muss ich bei der Definition der neuen Funktion die Sachen die ich benutzen will als Zeiger angeben, und sie dann als ganz normale Variable als Parameter angeben, wenn ich die Funktion aufrufe.

Wie sieht das denn aus, wenn ich in 'A' jetzt eine weitere Funktion, sagen wir mal 'B' aufrufen will, die Variablen und Arrays enthält, die in 'A' nicht vorkommen. Reicht es dann diese genau so nur für 'B' anzugeben, oder muss ich die dann auch in 'A' mit angeben?

Wieso hast Du bei der Definition der Funktion 'A' immer ein 'my_' vor die Variablen geschrieben?

Bine

PS: Außerdem habe ich das Problem, das mir der Compiler sagt, ' A does not take 3 parameters'! Wieso das? (Ich weiß darüber einfach noch nicht genug, hoffentlich hälts Du mich nicht für total bescheuert)!

<FONT COLOR="#a62a2a" SIZE="1">[ 17. Oktober 2001 08:39: Beitrag 1 mal editiert, zuletzt von Woodstock ]</font>

[haddock]

Hi Bine,

<BLOCKQUOTE><font size="1" face="Verdana, Arial, Helvetica, sans-serif">Zitat:</font><HR> hoffentlich hälts Du mich nicht für total bescheuert

[Woodstock]

Hmm, klappt nicht so wie es soll. Also, mal konkret. Ich will folgendes in einen anderen Quelltext 'auslagern', und zwar in die Funktion 'A':

do

{

cout << "Bitte das " << scnt2+1 << ". gesuchte Wort eingeben: ";

cin >> buffer2;

_strlwr(buffer2);

strcpy(Eingabe[scnt2], buffer2);

scnt2++;

} while (strcmp(buffer2, "---"));

Nachdem 'A' ausgeführt worden ist, will ich mit den veränderten Variablen weiter arbeiten, was bedeutet, ich muss sie 'per referenz' übergeben, oder? Das müsste doch dann in main so aussehen, oder?

A(&buffer2, &Eingabe, &scnt2);

und in meinem externen Quelltext so:

#include "Sabine(1).h"

void A(char* buffer2, char** Eingabe, int& scnt2)

{

do

{

cout << "Bitte das " << scnt2+1 << ". gesuchte Wort eingeben: ";

cin >> buffer2;

_strlwr(buffer2);

strcpy(Eingabe[scnt2], buffer2);

scnt2++;

} while (strcmp(buffer2, "---"));

}

Oder bin ich da jetzt voll auf dem Holzweg :confused: ?

Bine

<FONT COLOR="#a62a2a" SIZE="1">[ 17. Oktober 2001 12:00: Beitrag 15 mal editiert, zuletzt von Woodstock ]</font>

[haddock]

<BLOCKQUOTE><font size="1" face="Verdana, Arial, Helvetica, sans-serif">Zitat:</font><HR> Oder bin ich da jetzt voll auf dem Holzweg :confused: ?

[Woodstock]

Hmm, ok, also das mit dem Aufrufen und den & habe ich denke ich jetzt verstanden. Wenn ich also ein char Array (z.B. arr[100]) als Parameter übergebe, dann schreibe ich im Aufruf nur:

Funktion(arr);

wenn ich ein Array (z.B. arr1[100][100]) als Parameter übergeben will, dann schreibe ich im Aufruf:

Funktion(&arr1);

Richtig?

Bine

<FONT COLOR="#a62a2a" SIZE="1">[ 17. Oktober 2001 12:00: Beitrag 2 mal editiert, zuletzt von Woodstock ]</font>

[haddock]

Nur halb, der Typ des Parameters muß stimmen. Wenn du sagst

char arrggh[7][7];

ist der Typ von arrggh[0][0] char,

der von arrggh[0] ist char* (Zeiger auf char)

und der von arrggh ist char** (Zeiger auf Zeiger auf char).

Folgender Fall:

void a(char* x)

{...}

void b(char** y)

{...}

void main()

{

char arr[3];

char arrarr[2][4];

a( arr );

a( arrarr[1] );

b( &arr );

b( arrarr );

...

}

Für jede zusätzliche Dimension des Arrays muß auch eine weitere Indirektion des Zeigers erfolgen, damit der Typ immer stimmt. Ich weiß, das ist Anfangs hartes Brot...

[Woodstock]

So, jetzt ist es endgültig aus, also nochmal ganz von vorne (was würde ich bloß machen wenn es dieses Forum hier nicht gäbe).

Nehmen wir an, wir haben zwei Quelltexte, 'Eins' und 'Zwei'.

Nehmen wir weiter an, in Quelltext 'Eins' befindet sich die Funktion 'main', und in Quelltext 'Zwei' befindet sich die Funktion 'XY'.

So, nehmen wir weiter an, 'main' sähe so aus:

#include <iostream.h>;

void Zwei();

void main()

{

char a;

char b[5];

char c[5][10];

int d = 0;

cout << a << "\t" << b << "\t" << c << "\t" << d << "\t";

Zwei(?????????);

cout << a << "\t" << b << "\t" << c << "\t" << d << "\t";

}

und 'XY' so:

#include <iostream.h>

void Zwei(?????);

{

.

.

.

}

So weit, so gut, nehmen wir weiter an, in 'Zwei' wolle ich alle in 'main' definierten Variablen und Arrays verändern, und die veränderten Werte wiederum in 'main' ausgeben/weiterverarbeiten.

Das heißt ja, ich muss sie der Funktion übergeben. Wie?

Bine

PS:Bitte, hilf mir, ich vestehe nur noch Bahnhof!!! :confused:

<FONT COLOR="#a62a2a" SIZE="1">[ 17. Oktober 2001 13:19: Beitrag 1 mal editiert, zuletzt von Woodstock ]</font>

[haddock]

Also:

void XY(char* axy, char* bxy, char** cxy, int* dxy)

{

// Zugriff innerhalb:

*axy = 'm';

strcpy(bxy, "hohi");

bxy[1] = 'i';

strcpy(cxy[0], "eh-oh");

cxy[0][0] = 'o';

*dxy = 42;

}

Aufruf:

XY(&a, b, c, &d);

Der Haken sind die char-Arrays, bzw. Arrays davon. Leider werden in C Strings als nullterminierte Arrays von char dargestellt, weswegen die ersten beiden Parameter, obwohl scheinbar gleichen Typs, etwas Grundlegend unterschiedliches sind.

axy ist tatsächl ich ein Zeiger auf ein char, weswegen er im Funktionsrumpf dereferenziert werden muß.

bxy dagegen ist die Startadresse eines char-Arrays, die Dereferenzierung findet durch den [] Operator statt. Eigentlich (verzeihung, daß ich erst jetzt darauf komme ) kannst du auch wie folgt deklarieren:

void XY(char* axy, char[] bxy, char[][] cxy, int* dxy);

Dadurch ändert sich nichts, allerdings ist es vielleicht einleuchtender...

Noch zur Verwendung von char-Arrays, hast du diesen thread schon gelesen, da steht vielleicht auch ein bißchen Nützliches.

<FONT COLOR="#a62a2a" SIZE="1">[ 17. Oktober 2001 12:53: Beitrag 1 mal editiert, zuletzt von captain haddock ]</font>