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