Wer ist denn C Profi ?

[NightStalker]

& und [] gleichen sich deshalb aus, weil bei Arrays der Name auch ein Pointer auf das nullte Element darstellt. &arrayname[0] liefert dir also die Adresse des nullten Elementes. Und das ist logischerweise auch die Startadresse des Arrays, da kannst du auch gleich nur mit dem Namen draufzugreifen.
Aus dem gleichen Grund sind z.B. auch

*(zeiger+0) = *zeiger und
zeiger[0]
vollständig äuqivalent, davon jetzt die Adresse ergibt
&zeiger[0] = &(*(zeiger+0)) = zeiger + 0 = zeiger

[cyrano]

Ok also die erste variante funktioniert.
Der Shortcut allerdings nicht.
Das gibt einen parse-error. (und ich habe dreimal
geprüft ob es irgendein tipfehler ist. -> nein)
GCC-2.96

[Gast]

Wieso stehen im ursprünglichen Codeschnipsel überhaupt die ganzen "&" und "[0]" drin?
Also die [ ] zumindest, weil ein Device meist mehrere Interfaces und
endpoints besitzt. (Meins z.B. 2)

Okay, dann sind die [ ] natürlich berechtigt, aber in der header-Datei steht das ja (leider) nicht ausdrücklich drin, ob dies nun arrays von pointern oder nur ein einzelner pointer ist, und anhand der Deklaration ist beides möglich. (Das ist leider die Blödheit von C.)

Dachte bisher immer, dass & mir die Adresse des Pointers liefert

Haaaalt! Bitte rekapitulieren: Du hast einen Wert (z.b. ein "struct blabla meinwert;"). Du kannst nun mit & die Adresse von diesem Wert nehmen und hast damit einen pointer auf den Wert (der nämlich die Adresse von diesem Wert gespeichert hat), also "struct blabla *meinpointer = &meinwert;". Von diesem Pointer kann man, wenn man will, natürlich auch mit & die Adresse nehmen "struct blabla **zweiterpointer = &meinpointer;" und hat dann einen pointer auf einen pointer auf einen Wert, aber in deinem libusb-Beispiel kann ich mir kaum vorstellen, daß das beabsichtigt war.

Wieso gleichen sich & (Adress-OP) und [ ] (Adressierer eines Array ???) ueberhaupt aus ?????

Weil C blöde ist . Weil der Typ "Pointer auf Wert" (d.h. "Adresse von Wert") und "Array von Wert" in C äquivalent sind. Es ist also "struct blabla[25]" und "struct blabla *" der gleiche Typ, leider. Die Adressierung eines Arrays gibt ja den Wert in diesem Array. Wenn ich das erste Element (mit dem Index Null) in einem Array adressiere, kriege ich also den Wert, der genau an der Stelle steht, wo das Array liegt. Damit ist das genau das gleiche, wie wenn ich den Wert von einem Pointer nehme (mit dem Operator *). Das wiederum ist ja genau das Gegenstück davon, wenn ich die Adresse von einem Wert nehme (mit dem Operator &).

Also "struct blabla meinarray[25];" und "struct blabla *meinpointer;" sind in C vom gleichen Typ. Wenn ich nun einen Wert habe "struct blabla meinwert;", kann ich die Adresse davon nehmen "meinpointer = &meinwert;" und kriege den Wert mit "*meinpointer" wieder zurück. Und nun kann ich in C fieserweise auch so tun, als wäre dieser pointer der pointer auf ein ganzes Array: "meinarray = meinpointer;". Das erste Element davon (index Null) "meinarray[0]" ergibt dann wieder den Wert, ist also das gleiche wie "*meinpointer" oder eben auch "*meinarray". Damit ist also "&meinarray[0]" und "&meinpointer[0]" das gleiche wie "*&meinarray" und "*&meinpointer", also letztlich wieder "meinpointer" und fertig.

Wer meine Meinung hören will: Arrays in C sind unter anderem deswegen unglaublich beschissen. Lasst es bloß bleiben, die zu benutzen. Geht zu C++ und benutzt die STL-Container, z.B. std::vector<WerteTyp>.

Im letzten Kommentar hab ich nicht verstanden, welche "erste Variante" denn nun funktioniert. Und wenn der "shortcut" nicht auf Anhieb geht, kannst du den auch Schritt für Schritt zusammenbauen. Ich kann mir kaum vorstellen, daß der tatsächlich nicht akzeptiert werden würde, den solche Sachen schreib ich täglich hin.