Ich habe mit typedf eine Struktur erstellt. Jetzt habe ich ein Feld mit Objekten dieses Typs erstellt. Dieses Objekte lassen sich auch benutzen und einzeln per Zeiger an Funktionen übergeben. Allerdings würde ich gerne das ganze Feld an die Funktion übergeben, um den gesamten Ablauf dort zu haben.

Der Aufruf sieht derzeit so aus:

void zeichne_Objekte (MOVER *Objekte[],int Anzahl,BITMAP *Buffer1)

Der Kompiler akzeptiert den Code, allerdings kann ich die Routine nicht benutzen, da hier verschiedene Fehlermeldungen kommen. Unter anderem

cannot convert ** to *.

Jetzt habe ich drei Fragen:

1. geht mein Ansinnen überhaupt?
2. geht es mit dieser Deklaration?
3. kann man nur lesen oder dann auch schreiben?

Wer also beim Gummipunkte Lotto mitspielen möchte, nur zu :-))

Ich habe mit typedf eine Struktur erstellt.

Nein, hast Du nicht. typedef führt ein "Typ-Alias" ein.

Der Supercoder schrieb:

Jetzt habe ich ein Feld mit Objekten dieses Typs erstellt.

Ok.

Der Supercoder schrieb:

Der Aufruf sieht derzeit so aus:

void zeichne_Objekte (MOVER *Objekte[],int Anzahl,BITMAP *Buffer1)

Das ist kein Aufruf. Es könnte aber eine Deklaration werden, wenn Du noch ein Semikolon anhängst. Beachte, dass der Typ des ersten Parameters MOVER** ist -- also ein Stern zuviel, wenn Dein Feld direkt die Objekte speichert und nicht Zeiger auf die Objekte. Das [] spielt bei bei Parametertypen eine Sonderrolle: Ein Postfix-[] auf oberster Ebene wird durch ein Präfix-* ersetzt. Arrays können nicht übergeben werden, sondern nur Zeiger und Referenzen. Folgende zwei Deklarationen sind wegen dieser Sonderbehandlung identisch:

void foo(double * blah);
void foo(double blah[]);

Benutzt Du als Argument ein Feld, wird einfach ein Zeiger auf das erste Element übergeben (array to pointer decay).

Der Supercoder schrieb:

Der Kompiler akzeptiert den Code, allerdings kann ich die Routine nicht benutzen, da hier verschiedene Fehlermeldungen kommen. Unter anderem

cannot convert ** to *.

Das ist kein Wunder.

void func(int * zeiger){}
void func(int[] zeiger){} //völlig gleichwertige Deklaration

Es müsste int zeiger[] heißen. Deklarationen sind das auch nicht. Es sind Definitionen.

void zeichne_Objekt (Mover *Objekt,....) {...}

schreibe kann ich hinterher nicht in der von mir gewünschten weisse darauf zugreifen.

Hinterher soll

Objekt [Index]->x += XY;

usw stehen. Hier bekomme ich dann aber den Fehler, dass es die Basis von -> kein Zeiger wäre

Wie siehts denn damit aus?

...
Hinterher soll

Objekt [Index]->x += XY;

usw stehen. Hier bekomme ich dann aber den Fehler, dass es die Basis von -> kein Zeiger wäre

Stimmt ja auch. Entweder Du schreibst

Objekt[Index].x += XY;

oder

(Objekt+Index)->x += XY;

Am besten wiederholst Du das Zeiger-Kapitel in Deinem C++ Buch.

Objekt[Index].x produziert übrigens mit einiger Wahrscheinlichkeit eine Fehlermeldung.

Wenn, dann solltest Du (Objekt[Index]).x verwenden. Zumindest sieht mein Compiler das so.

Allerdings wäre es immernoch ganz schön, wenn mir jemand bei meinem Problem helfen könnte.

Objekt[Index].x produziert übrigens mit einiger Wahrscheinlichkeit eine Fehlermeldung.

Arbeitet dein Compiler probabilistisch?
Was verwendest du überhaupt?

Zudem wäre es gut, zusammenhängende Informationen zu erhalten. Kannst du die Deklaration (Definition nicht nötig) von allen verwendeten Typen und die aktuelle Fehlermeldung mit Bezug auf die fehlerhafte Codezeile zeigen?

Allerdings wäre es immernoch ganz schön, wenn mir jemand bei meinem Problem helfen könnte.

Ich sehe das so, dass man Dir für die Infos, die Du rausgerückt hast, ganz gute Hilfe gegeben hat. Mehr ist ohne Wahrsagerkugel nicht drin. Vielleicht reflektierst Du nochmal drüber ... schaust doch nochmal im Zeiger-Kapitel Deines C++ Lehrbuchs rein ... oder verrätst einfach n bissel mehr ... .zB ein komplettes aber minimales Codebeispiel, das Deiner Meinung nach kompilierbar sein sollte ...

Die Lösung Objekt[Index].PosX war nach Änderung der Deklaratiion

void zeichne_Objekte (MOVER *Objekte,int ...) {}

und des Aufrufs

zeichne_Objekte (&Objekte[0],Anzahl])

funktionsfähig.

Allerdings ist sie als Substitut für

Objekte[Index]->PosX

falsch

(Objekte[Index]).PosX

wäre hier der Preis gewesen.

[... bla bla bla ...]

Spuck mal nicht so große Töne. Du hast hier 1A Hilfe bekommen. Dass Dir die Antworten nicht gefallen haben, liegt daran, dass Deine Frage keinen Sinn ergibt. Wenn Du auf Aufrufer-Seite ein Array aus Objekten hast

class Object {
  public:
    double PosX;
};

...

int main() {
  Object array[2];
}

und Du in der Funktion, die das "Array übergeben bekommt", auf die Elemente wie folgt zugreifen willst

void funktion( ...param... ) {
  param[0]->PosX = 23;
  param[1]->PosX = 42;
}

dann hast Du ein paar Lektionen über Arrays und Zeiger verpasst und scheinbar auch die meisten Antworten hier in diesem Thread einfach nicht verstanden. Wie der Compiler Dir schon sagte, muss vor "->" ein Zeiger stehen (abgesehen von einem benutzerdefinierten operator->). Wenn param[0] aber ein Zeiger sein soll, hättest Du ein Array aus Zeigern. Das passt aber nicht mit dem Array in main() zusammen -- das Runde geht nicht in das Eckige, ne? :p Das ist auch nichts neues und wurde hier schon erwähnt. Die Lösung gabs hier auch schon:

void funktion( Object param[] ) {
  param[0].PosX = 23;
  param[1].PosX = 42;
}

und funktioniert übrigens ganz ohne Klammerung, superloser.