Variablen in einer Funktion bekannt machen

[hosti]

Guten Morgen,

Ich suche nach einer möglichkeit in einer Funktion mit Variablen zu arbeiten die nicht als Parameter übergeben werden müssen.

Ich habe zum beispiel eine datei main.c

Dort rufe ich die Funktion Berechnung; auf

Diese arbeitet mit Variablen die in 3 anderen Files deklariert und auch definiert werden.

Das Problem ist jetzt aber das es sehr viele sind,
z.B. 5 Arrys, 17 Variablen

Und in dieser Funktion überprüfe ich ob die Werte in den Arrays bestimmten Werten entsprechen. Ist dies der Fall wird eine Variable gesetzt.
Die Funktion wird aber wie folgt aufgerufen


Funkion(Array1, variable)
oder auch
Funktion(Array2, variable)

Jetzt müsste ich aber wissen Welches Array in der Funktion genutzt wird, sprich Array1 oder 2 oder 3 etc.

Oder ich könnte auch alle Arrays übergeben aber das wird extrem unübersichtlich. Deshalb suche ich eine möglichkeit in der Funktion mit den Arrays zu arbeiten ohne diese als Parameter zu übergeben. Ich hoffe dies ist halbwegs verständlich.

Beispiel

void Berechnung(int 1, int 2, int 3, int 4, int 5, int *array)
{
if(array[3] = 150)
{
1 = 12;
}
else
{
1 = 15;
}
}

Oder

void Berechnung(int *array1, int *array2)
{
if(array1[3] = 150)
{
array2[4] = 12;
}
else
{
array2[2] = 15;
}
}
Die Funktion Berechnung wir mit verschiedenen Arrays aufgerufen.
Je nach dem mit welchem Array wird der Wert in eine andere Variable geschrieben.

Jetzt müsste ich die Funktion mit allen Array's als Parameter aufrufen und dann alle auswerten und die Variablen setzten.
Dann wäre es aber schön, wen ich nicht alle übergeben müsste.

Oder wen es eine Möglichkeit gäbe zu sehen mit welchem Array die Funktion aufgerufen würde müsste ich nur dieses Auswerten was auch eine gute Lösung wäre.

Ich hoffe ihr könnt mir da weiterhelfen

[Felix G]

Also, du übergibst der Funktion ein Array und weitere zusätzliche Parameter, und jetzt soll die Funktion anders reagieren, je nachdem welches konkrete Array du übergeben hast?

Wenn man auf derartige Probleme stößt, ist es normalerweise an der Zeit das Grundkonzept nochmal zu überdenken. Denn in diesem Fall gibt es Abhängigkeiten wo keine sein dürften, und sowas macht ein Programm mit der Zeit extrem unübersichtlich.


Wenn du Daten hast die in irgendeiner Form zusammen gehören, also z.B. ein Array "A1" und die Variablen "B1", "C1" und "D1", ist es z.B. oft gut structs einzusetzen und nur mit diesen zu arbeiten...

Ob das in deinem Fall sinnvoll ist oder nicht, kann ich dir aber nicht sagen, dafür wären mehr Informationen zu deinem Programm notwendig

[MichaF]

Wirklich verstanden habe ich nicht was du meinst ;)

Prinzipiell hat Felix Recht, in solchen Fällen ist es höchste Zeit seine Variablen in ein struct zu packen. Dann reicht es aus, einer Funktion einen Pointer auf ein solches Struct zu übergeben. So lassen sich auch große Datenmengen übersichtlich handhaben.

Eine andere Möglichkeit wäre noch, die zu bearbeitenden Daten als globale Variablen zu deklarieren, dann kannst du von jeder beliebigen Stelle im Programm auf sie zugreifen. Schön ist das aber imho nicht.

Oder wen es eine Möglichkeit gäbe zu sehen mit welchem Array die Funktion aufgerufen würde müsste ich nur dieses Auswerten was auch eine gute Lösung wäre.
Naja, eigentlich verfügst du doch schon über diese Information. Wenn du die Funktion aufrufst, weißt du ja auch, was du ihr als Parameter übergeben hast.

Wenn es dir aber nur darum geht eine Funktion zum Bbearbeiten von X Variablen nicht X mal aufrufen zu müssen, bis du beim Thema structs richtig.

[hosti]

Gibt es den keine Möglichkeit globale Variablen in einem externen File zu erstellen? müssen die Zwangsläufig im Main sein?

[Martin.]

Globale Variablen gibt es schon:



int a = 0;

int main()
{
a++;
std::cout << a << std::endl;
}

Das packt normalerweise ein c/c++ Compiler aber es ist keine saubere Lösung eine Variable über so einen großen Bereich zu definieren.

Wenn du jetzt mehrere Files hast und var a int Da.c definiert wird, dann kannst du sie in Da.h als

extern int a;
deklarieren. Nun kannst du in main.c via include "Da.h" auf die Variable a zugreifen.

[sast]

Nehmen wir mal an, du hast eine Datei daten.c in der 3 arrays definiert sind mit char arr1[30], arr2[50], arr3[30];
In diese packst du eine Funktion char get_arr_value(int arr, int pos);
In der Funktion kannst du über switch case ein array auswählen. Nun überprüfst du pos mit den array Grenzen und gibst wenn es passt den Inhalt vom ausgewählten Array zurück. int arr ist hierbei eine beliebige Nummerierung. ZB. 1:arr1, 2:arr2 usw
In daten.h deklarierst du extern char get_arr_value(int, int); und includierst die daten.h in deiner main.c
Mit dem Aufruf char c=get_arr_value(1, 0); in der main.c holst du dir hierdurch den Inhalt des arrays arr1[0].

Wenn du allerdings mit structs arbeitest, hast du noch viel weitreichendere Möglichkeiten. Dann kannst du dem Nutzer der daten.c eine Menge Informationen an die Hand geben. Du kannst dem Array einen Namen verpassen, die Größe mitgeben usw.

typedef struct c_arr
{
char name[20];
int length;
char* arrX;
...
}c_arr_t;

c_arr_t carr1, carr2;

carr1.arrX = arr1;
carr2.arrX = arr2;
carr1.length = 30;
carr2.length = 50;
...

sast

[hosti]

Das Problem ist aber, das ich die Variablen die ich in der Funktion(mit den vielen parametern) benutze auch in anderen Funktionen nutze

Als Beispiel in eine Funktion die, die der Funktion übergebenen Parameter multipliziert.
Abhängig davon ob ich die Funktion mit var1 oder var2 oder varn
aufrufe. Das ergebnis gibt die Funktion anschliessend zurück.

Das kann ich mit stuct ja nicht mehr, da ich nicht entscheiden kann, welche bestimmte Variable ich zum Aufrufen nutze.

Oder habe ich das falsch verstanden?

[sast]

In den structs ist doch immer ein Pointer auf ein dazugehöriges Array. Theoretisch reicht auch die extern Variante des Arrays, aber im Struct kannst du noch Zusatzinfos ablegen. Structs sind sozusagen die Urformen von Klassen, falls dir das als Verständnisversuch weiterhilft.

get_arr_value ist ja auch nur ein Beispiel für so eine kapselnde Funktion, in der du bereits Bereichsüberprüfungen usw vornehmen kannst.
Man könnte auch einfach eine char* get_array(int arr); Funktion dazu verwenden, um den Pointer auf das Array zu bekommen. Das ist dann ähnlich wie wenn du die Variante von Martin. nimmst, nur mit der erweiterten Möglichkeit von Überprüfungen usw. Auf das Array kannst du dann über den Pointer direkt zugreifen.

Wenn du wie oben beschrieben auf bestimmte Positionen im array zugreifen willst und das dann auch noch mit 2 Arrays, dann musst du zu den Arrays auch immer die Positionen und/oder extra Berechnungsparameter an deine Berechnungsfunktion übergeben. Wenn du nicht nur im Array etwas verändern willst, dann sollte vielleicht deine Funktion kein void als Rückgabewert liefern, sondern das Ergebnis der Berechnung.



int Berechnung1(int arr1, int pos1, int arr2, int pos2, int faktor, int subtrahend, char wasweissich)
{
switch(wasweissich){
case 'x':
return = get_array_value(arr1, pos1) - subtrahend;
break;
case 'a':
return = get_array_value(arr2, pos2) * faktor;
break;
case 'b':
set_array_value(arr1, pos1, (get_array_value(arr2, pos2) * faktor));
return = get_array_value(arr1, pos1);
break;
...
default:
break;
}
return 0;
}
int a = Berechnung1(1,0,2,25,1,0,'x');


Die Datentypen sind jetzt nicht mehr richtig stimmig, aber das musst du sowieso an deine Aufgabe anpassen.

sast

[hosti]

Ich werds mit strukturen versuchen.

Leider klappt das nicht ganz, wen ich folgendes schreibe (daten.c)


typdef struct daten{
double var[3] = {1,2,3};
double h = 0;
float w1;
float w2;
}daten;

kriege ich die Fehlermeldung das er for struct ein = , ; erwartet.

Und was muss ich in die headerdatei schreiben?

[sast]

typedef ist ein Schlüsselwort
statt "typdef struct _daten" schreibst du "typedef struct _daten"
auch ein e ist manchmal wichtig
und ein array deklarierst du in der Headerdatei mit
extern daten data1, data2; usw

Edit: Aber eigentlich hab ich immer von Funktionen gesprochen und in dem Fall brauchst du nur die extern get_arr_value(int, int) usw im Header. Den direkten Zugriff bekommst du ja einfach über extern char arr[X]. Den hatte ich ja ausgeschlossen. Dann kannst du aber auch alles wieder vergessen, was ich bisher gesagt habe.

sast

[hosti]

danke für die Antwort, das fehlende e ist ein schreibfehler (Ich habs abgetippt)

Das ist also nicht der Grund für die Fehlermeldung.

Diese Struktur ist nur ein Test um die Funktion zu verstehen.

Jetzt merke ich gerade selbst den Fehler, in einer Struktur kann ich keine Werte zuweisen...
Damit mache ich ja nur das Grundgerüst.

Erst wen ich schreibe z.B. daten daten1;
Habe ich eine Struktur daten1 der ich auch Werte zuweisen kann, ist das richtig?

[sast]

Jetzt wo du es erwähnst. Ich würde anstelle deines var[3] auch lieber ein *arr also einen Pointer auf ein array nehmen, da du sonst ja die Flexibilität verlierst. Du wolltest ja verschieden große array verwenden, oder hab ich das falsch verstanden?

Mit z.B.
char var[3];
data1.arr = var;
hast du ja dann später das Array in arr verfügbar.

sast

Mit einem typedef definierst du einen Datentyp. Das Datum selbst ist dann nur als dieser Datentyp deklariert.

[hosti]

Also dann schreibe ich folgendes



typedef struct daten{
double var[3];
double h;
float w1;
float w2;
}daten;


Wie weise ich den am einfachsten allen Variablen die Werte zu?

Und kannst du mir bitte ein Beispiel schreiben, was ich in das *.c und das *.h file schreiben muss wen ich z.B. 3 Strukturen vom Typ daten brauche?

[sast]

Hmm,

das hab ich doch alles schon geschrieben. Und meinen Hinweis mit dem Pointer auf das Array hast du auch gleich wieder geschickt ignoriert.

Lies mal meinen ersten und den letzten Post nochmal durch. Dann versuchst du da was draus zu machen und wenn dann noch Fragen offen sind ... bin ich bestimmt heute abend nochmal online.

Ach so du musst doch nur eine struct definieren und dann davon mehrere Variablen anlegen und dem pointer das entsprechende Array übergeben.

sast

[hosti]

Entschuldige, ich glaube ich hab mich etwas falsch ausgedrückt

Wen ich daten1 erstelle, gibt es eine Möglichkeit gleich alle Werte beim erstellen zuzuweisen?

Also im sin von
daten daten1 ={1,2,3,4,5,6) oder muss ich wirklich
daten1.var[1] = 1;
.....
....
daten1.h = 4;
.....
schreiben?

(Oder mit dem Pointer
daten1.var =arr;)

Ich hoffe meine Beschreibung ist verständlich

[sast]

wie wäre es denn mit einer daten.h

typedef struct _daten{
int id;
char *arr;
int length;
...
}daten;

extern int Berechnung1(int arr1, int pos1, int arr2, int pos2, int op1, int op2, char opid);
extern char get_arr_value(int arr_nummer, int arr_pos);
extern char* get_arr(int arr_nummer);
extern void set_arr_value(int arr_nummer, int arr_pos, char value);
...

und in der daten.c mit

daten data1, data2, data3;
char feld1[] = {1,2,3,4,5};
char feld2[] = {6,7,8,9,10};
char feld3[10];

data1.id = 1;
data2.id = 2;
data3.id = 5;
data1.arr = feld1;
data2.arr = feld2;
data3.arr = feld3;
data1.count = 5;
data2.count = 5;
data3.count = 10;

char get_arr_value(int arr_nummer, int arr_pos)
{
...
char result = SR_ERROR;
switch(arr_nummer){
case 1:
... //feldbereich überprüfen auf gültigkeit
result = *(data1.arr+arr_pos); //feld1[arr_pos];
break;
case 2:
...
}
return result;
}

char* get_arr(int arr_nummer)
{
...
}

...


und in der main.h

...
int res;

res = Berechnung1(1,0,2,0,8,1,'A');
set_arr_value(5,4,get_arr_value(1,2));
set_arr_value(5,0,(char)(res));
//usw
...

Ich weiß nicht wie ich mich sonst noch verständlicher ausdrücken soll, ohne dir die ganze Arbeit abzunehmen. Ansonsten beißt dich der Compiler auch nicht, wenn du einfach mal eine Idee ausprobierst. Im schlimmsten Fall gibt es eine Fehlermeldung, oder bei der Ausführung eine Exception, wenn du doch mal den Bereich falsch angegeben hast in der daten.c

sast