Variablen indiziert ansprechen?

[Index (Gast)]

Hallo,

gibt es in C eigentlich die Möglichkeit, Variablen bzw. Arrays zu 
indizieren und diese indiziert anzusprechen?

also irgendwie so etwas in der Form

int Var1;
int Var2;
int Var3;

for(int j=1; j<3, j++)
{
Varj = irgendwas();
}

(mir ist klar, dass das SO wie oben nicht funktioniert, aber es 
illustriert meinen Wunsch wohl recht gut. Gibt es die Möglichkeit in 
einer ähnlichen Form das zu erreichen, was ich hier versuche?

mfg

[Karl H. (kbuchegg)]

Index schrieb:

> also irgendwie so etwas in der Form
>
> int Var1;
> int Var2;
> int Var3;
>
> for(int j=1; j<3, j++)
> {
> Varj = irgendwas();
> }
>

Gratuliere. Du hast soeben das Array, bzw. die Motivation hinter einem 
Array entdeckt.

int Var[3];

  for(int j=0; j<3, j++)
  {
    Var[j] = irgendwas();
  }

[Index (Gast)]

...ja meine Aufgabe hat auch tatsächlich mit Arrays zu tun. Tatsächlich 
sind es nämlich 8 Arrays, die ich gerne indiziert ansprechen würde.

Also Array_1 bis Array_8.

Ich kann mir nicht vorstellen, dass es nicht eine sinnvolle Möglichkeit 
gibt, Variablen ohne ein Array indizierbar ansprechen zu können...

Ansonsten müsste ich ja meine bisherigen Arrays in die Tonne werfen und 
alle Daten in ein einziges Array packen.
Wenn ich diesen Weg konsequent weiterverfolge, müssten alle 
Programmdaten aus einem einzigen Array bestehen, in welches ich einfach 
alles hintereinander aufreihe... Das kann's ja irgendwie auch nicht 
sein.

[Falk B. (falk)]

@ Index (Gast)

>sind es nämlich 8 Arrays, die ich gerne indiziert ansprechen würde.

Es gibt auch mehrdimensionale Arrays.

int my_array[5][8];

>Ich kann mir nicht vorstellen, dass es nicht eine sinnvolle Möglichkeit
>gibt, Variablen ohne ein Array indizierbar ansprechen zu können...

Nö, gibt es nicht.

[Murkser (Gast)]

Mehrdimensionale Arrays?

[Yalu X. (yalu) (Moderator)]

Es lassen sich auch Arrays von Zeigern auf andere Arrays anlegen. Ob man 
besser ein mehrdimensionales Array (d.h. ein Array von Arrays) oder ein 
Array von Zeigern verwendet, hängt stark vom konkreten Anwendungsfall 
ab.

[Reinhard Kern (Gast)]

Falk Brunner schrieb:
> Nö, gibt es nicht.

Und sinnvoll wäre es auch nicht. Es gibt garkeine Garantie, dass 
einzelne Variablen im Speicher hintereinander abgespeichert werden, 
damit entfällt ein berechneter Zugriff. Der Compiler müsste also die 
indizierten Zugriffe per Compiler magic umsetzen in direkte 
Variablenzugriffe, aber das ist dummes Zeug. Der Programmierer wird ja 
wohl noch wissen, ob es sich um ein Array handelt oder um unabhängige 
Variablen, wer denn sonst?

Ein Konstrukt wie "for i= Farbe to Verpackungseinheit" ist völlig 
sinnfrei.

Gruss Reinhard

[Karl H. (kbuchegg)]

Index schrieb:

> Programmdaten aus einem einzigen Array bestehen, in welches ich einfach
> alles hintereinander aufreihe... Das kann's ja irgendwie auch nicht
> sein.

Ist es auch nicht.
Je nach Anwendungsfall und Aufgabe gibt es auch noch andere 
Möglichkeiten der Datenorganisation.
Wenn aber ein indizierter Zugriff erforderlich ist (aus welchem Grund 
auch immer), dann liegt genau der Fall vor, der mit einem Array 
abgebildet wird. Das kann auch ein Array von Arrays sein, oder ein Array 
von Arrays von Arrays, oder ....
D.h. eine der Fargestellungen bei der Auswahl der anzuwendenden 
Datenstruktur lautet auch: welche Form des Zugriffs brauche ich 
eigentlich? Muss ich nur ein Element nach dem anderen besuchen können, 
oder benötige ich tatsächlich das Mittel des wahlfrei berechenbaren 
Indexes, um auf die Daten zuzugreifen. In letzterem Fall landet man dann 
eben beim Array. Im ersten Fall kann ein Array das Mittel der Wahl sein, 
muss es aber nicht. Da gibt es auch noch Listen (einfach und doppelt 
verkettet) und die ganze Familie diverser Bäume sollten dann auch noch 
ihre Erwähnung finden. Genauso, wie es selbstverständlich sinnvoll sein 
kann, diverse Mischformen in einer kompletten, komplexen Datenstruktur 
zu benutzen.

Programmieren ist eben mehr als nur die Kenntnis über 5 Schlüsselwörter 
und los gehts mit dem programmieren.

[Klaus W. (mfgkw)]

int Var1;
int Var2;
int Var3;

int *pVari[3] = { &Var1, &Var2, &Var3 };

for(int j=0; j<3, j++)
{
   *pVari[j] = irgendwas();
}

Zu beachten, daß der Index ab 0 läuft (bis 2).

Will man das vermeiden und Indices von 1 bis 3 nehmen, kann man einen 
kleinen Kniff anwenden:

int Var1;
int Var2;
int Var3;

int  *pVari_tmp[3] = { &Var1, &Var2, &Var3 };
int **pVari = &pVari_tmp[-1];

for( int j=1; j<=3; j++)
{
    ... *pVari[j] ...;
}

[Rufus Τ. F. (rufus)]

Klaus Wachtler schrieb:
> Will man das vermeiden und Indices von 1 bis 3 nehmen, kann man einen
> kleinen Kniff anwenden:

Hältst Du das für eine gute Idee?

[decius (Gast)]

Also mit der foolgenden Zeile habe ich Bauchschmerzen.

int **pVari = &pVari_tmp[-1];

Nicht das es nicht funktionieren würde. Aber wenn ein Zeiger benutzt 
wird der auf einen undefinierten Bereich zeigt, sträubt sich einfach 
alles in mir.
Undefiniert in dem Sinne das man nicht weis, was auf der Adresse vor dem 
Array liegt.

[hans (Gast)]

decius schrieb:
> Nicht das es nicht funktionieren würde. Aber wenn ein Zeiger benutzt
> wird der auf einen undefinierten Bereich zeigt, sträubt sich einfach
> alles in mir.
> Undefiniert in dem Sinne das man nicht weis, was auf der Adresse vor dem
> Array liegt.

Vorallem falls dann doch mal jemand mit Array[0]= xxx; anfängt :-)

[Klaus W. (mfgkw)]

Rufus Τ. Firefly schrieb:
> Hältst Du das für eine gute Idee?

In dieser reinen Form ist es wohl fragwürdig.

Den Mechanismus nutze ich aber tatsächlich, allerding in einer 
C++-Klasse (bzw. template) verpackt für Felder mit beliebigen Grenzen, 
je nach Fall negative und/oder positive Indices, ggf. auch neben der 
Null.

[Klaus W. (mfgkw)]

decius schrieb:
> Nicht das es nicht funktionieren würde. Aber wenn ein Zeiger benutzt
> wird der auf einen undefinierten Bereich zeigt, sträubt sich einfach
> alles in mir.
> Undefiniert in dem Sinne das man nicht weis, was auf der Adresse vor dem
> Array liegt.

Du sollst ja auch nicht auf das zugreifen, worauf der Zeiger zeigt.
Wie bei jedem Feld ist es in C möglich und verboten, neben das Feld zu 
greifen. Nur halt mit dem Unterschied, daß man hier nicht mehr [0] bis 
[n-1] anfassen darf, sondern dann [1] bis [n].

Wenn man nicht weiß, was man tut, sollte man sowas bleiben lassen.
Das gilt aber immer bei Verwendung von Zeigern...

[Sven P. (Gast)]

Klaus Wachtler schrieb:
> Du sollst ja auch nicht auf das zugreifen, worauf der Zeiger zeigt.
> Wie bei jedem Feld ist es in C möglich und verboten, neben das Feld zu
> greifen. Nur halt mit dem Unterschied, daß man hier nicht mehr [0] bis
> [n-1] anfassen darf, sondern dann [1] bis [n].

Ist aber trotzdem problematisch. C99 garantiert lediglich, dass der 
Zeiger auf das nächste Element hinter dem Array verrechnet werden 
darf. Das heißt, bei einem 'int v[10]' darf man wie üblich auf v[0] bis 
v[9] zugreifen und der Zeiger &v[10] existiert (er darf aber nicht 
dereferenziert werden).

Dagegen ist aber &v[-1] undefined behaviour.

[(prx) A. K. (prx)]

Sven P. schrieb:
> Dagegen ist aber &v[-1] undefined behaviour.

Es setzt nämlich voraus, dass &v[-1]+1 == &v[0], und das ist zwar 
üblicherweise der Fall, aber nicht gewährleistet. Es wäre nämlich 
durchaus zulässig, für solche Rechnungen eine Art saturierender 
Arithmetik zu verwenden, z.B. bei segment:offset Darstellung von 
Adressen.

[Martin (Gast)]

Sven P. schrieb:
> Dagegen ist aber &v[-1] undefined behaviour.

jepp.
Verbannt die pascalische Denkweise.
Alle Dinge beginnen von 0 .. aus dem Nichts.
Gleich wird's philosophisch :)

[Martin (Gast)]

Zum Topic:

Ich glaube TO sucht multidim. arrays.
Entweder als type[][] oder als jagged arrays, aber das geht
schon Richtung Implementierung.

@TO
Kannst du mehr zu deiner eigentlichen Problemstellung sagen?
Dann kann dir sicher jemand eine passender Datenstruktur anbieten.
Viele Räder sind schon erfunden.