was ist besser

besser schrieb:

oder *(foo+x)

wenn foo ein array ist, dann auf jeden fall erteres. bei 'nem pointer kommts auf die verwendung an, was im endeffekt lesbarer aussieht und so. kann man generell nicht sagen.

supertux

besser schrieb:

oder *(foo+x)

ich habe gehört, dass beim letzteren die Bits um 10% schneller in die CPU ankommen, wegen der runden Klammer

A ist besser als B impliziert immer, dass man sie bzgl. einem Standpunkt vergleicht. Deine Frage ist ist somit sinnlos, denn man weißt nicht, was du überhaupt vergleichst.

supertux schrieb:

ich habe gehört, dass beim letzteren die Bits um 10% schneller in die CPU ankommen, wegen der runden Klammer

selten so ausgiebig gelacht

supertux schrieb:

A ist besser als B impliziert immer, dass man sie bzgl. einem Standpunkt vergleicht. Deine Frage ist ist somit sinnlos, denn man weißt nicht, was du überhaupt vergleichst.

besser ist die steigerung von 'gut', weil aber 'gut' auch nicht kontextunabhängig ist, ist die frage doppelt sinnlos. *fg*

noobLolo schrieb:

supertux schrieb:

ich habe gehört, dass beim letzteren die Bits um 10% schneller in die CPU ankommen, wegen der runden Klammer

selten so ausgiebig gelacht

vom aussehen her müsste eigentlich 'foo[x]' viel-viel schneller sein, hat es doch kein + und auch kein * drin. *gg*

supertux

hat vier Ecken, wo die Bits anhalten müssen, bevor sie weiter fahren können.

edvoler

es is ganz egal wie man es schreibt, weil der compiler es sowieso zu

*(foo+x)

übersetzt. deswegen könnte man lustigerweise sogar statt

foo[x]
x[foo]

schreiben (zumindest beim Gnu gcc compiler)

@edvoler: Könntest Du das etwas näher erläutern? 32 Bit System. Pointer sind 4 Byte, die Adressen also immer durch 4 Teilbar. Doubles seien auf meinem System 8 Byte lang. Es sei:
foo=4000 und zeigt auf 10 Doubles.

Nun möchte ich auf den 2 Double zugreifen:
foo[1] wird zu 8000+2*8=8016

Deiner Umformung nach sollte auch dieses gehen:
1[foo] wird zu 1+8000*16

--------- schrieb:

Nun möchte ich auf den 2 Double zugreifen:
foo[1] wird zu 8000+2*8=8016

foo[1] wird zu *(foo + 1), das ist *(4000 + 8), das ist *4008.

--------- schrieb:

Deiner Umformung nach sollte auch dieses gehen:
1[foo] wird zu 1+8000*16

1[foo] wird zu *(1 + foo), das ist *(8 + 4000), das ist auch *4008.

edvoler

naja ehrlich gesagt bin ich mir bei double nicht sicher, wüsste aber nicht warums nicht gehen sollte...

aber das stimmt zB.:

int f[100]={};

//normalerweise wirst du zB auf das 5. element so zugreifen:
f[5]=...
//du kannst es aber auch so machen:
5[f]=...

ja ich war auch sehr verwundert als ich es zum ersten mal gesehen hab.
aber der compiler macht 5[f] bzw. f[5] IMMER zu *(f+5)
und bei additionen kann man ja die summanden vertauschen
*(f+5) = *(5+f)

@edvoler

solltest du beim compilieren eine warnung erhalten

= {0};
statt
= {};

lg lolo

edvoler

nein, eigentlich nicht xD
ist vielleicht compiler-abhängig

ja komisch hab das gerade nochmal getestet, hab mir gerade eingebildet mal nen fall gehabt zu haben wo ich ne warnung bekommen hab, ne 0 rein und dann war sie weg...

lg lolo

edvoler

ja egal... xD
aber was ich oben mit dem ausdruck verwandeln gesagt hab stimmt xDD

knivil

32 Bit System. Pointer sind 4 Byte, die Adressen also immer durch 4 Teilbar.

Diese Logik ist nicht einsichtig.

ach ja so war das, keine warnung sondern ein fehler

int *a={};
int *b={0};
int c[]={};
int d[]={0};

denk ich hab mal aus den [] ein * gemacht und dann ging das mit dem {} nicht mehr und dann mußte da ne 0 rein, ja ich hätte dann auch die klammern weg machen können, wollt das nur mal reproduzieren, dachte schon ich seh gespenster

lg lolo

Ok, mein letztes Posting war totaler Humbug. Das heißt bei 2[foo] wird die 2 so aufgefasst als wenn sie die Breite des Datentypes von foo hat.

Die Adressen müssen nicht durch 4 teilbar sein, da man zB Pointer in einem Char Array haben kann. knivil hat Recht.

--------- schrieb:

Ok, mein letztes Posting war totaler Humbug.

fein da haben wir was gemeinsam wobei deine nicht ganz so schlimm waren wie meine

--------- schrieb:

Das heißt bei 2[foo] wird die 2 so aufgefasst als wenn sie die Breite des Datentypes von foo hat.

Nö, die 2 wird so aufgefasst, als wenn sie die Breite eines int's hätte. Du bist nicht zufällig nwp2?

µngbd schrieb:

Du bist nicht zufällig nwp2?

ja mei irgend wann treffen sich alle im tal der aussätzigen

µngbd schrieb:

Du bist nicht zufällig nwp2?

wo steckt unser malloc-fetischist eigentlich? lange nichts mehr gelesen von ihm.