C Inhalt von 2 Variablen tauschen ohne zwischen speichern

1

#define x y

2

#define y x

Hat sogar überhaupt keine Laufzeitkosten!

Jemand schrieb:
> #define x y
> #define y x

1. April ist vorbei.

In 
[[https://graphics.stanford.edu/~seander/bithacks.html#SwappingValuesSubAdd]] 
wird es mit Addition und Subtraktion gezeigt.

Hanns schrieb:
> In
> [[https://graphics.stanford.edu/~seander/bithacks.html#SwappingValuesSubAdd]]
> wird es mit Addition und Subtraktion gezeigt.

Wobei das nur für unsigned int definiert ist und bei signed int 
undefined behaviour.

Hanns schrieb:
> In
> [[https://graphics.stanford.edu/~seander/bithacks.html#SwappingValuesSubAdd]]
> wird es mit Addition und Subtraktion gezeigt.

1

If you enable overflows exceptions, then pass unsigned values so an exception isn't thrown.

Wenn man diese Variante für signed integer benutzt möchte, sollte man 
vorher nach unsigned casten, damit man kein undefined sondern 
implementation defined behavior hat. Oder besser gleich die xor Variante 
nehmen die für signed und unsigned geeignet ist.

1

Don't use this with floating-point numbers (unless you operate on their raw integer representations).

Was ist die raw integer representation eines floats?

mh schrieb:
> Was ist die raw integer representation eines floats?

Das, was du bekommst, wenn du per Union eine Gleitkommazahl als Integer 
interpretierst.

Warum?

Offensichtich geht es um C (steht in der Überschrift, und du machst dir 
um undefined behaviour Sorgen).
Du weißt also eh nicht, was nach dem Optimieren raus kommt.

Warum nimmst du nicht die am einfachsten zu verstehende Lösung, bei der 
du noch hoffen kannst dass auch der Compiler versteht was du willst, 
weil er das Muster erkennt (mit Zwischenspeichern) und läßt den Compiler 
optimieren?

Und wenn die Variablen Strings sind? Oder struct-Variablen?

Hier, mal ganz was erstaunliches ;-)

1

    int x=10;

2

    int y=20;

3

    printf("vorher: x=%d, y=%d\n", x,y);

4

5

    x=x+y;

6

    y=x-y;

7

    x=x-y;

8

9

    printf("nachher: x=%d, y=%d\n", x,y);

Ausgabe:

1

vorher: x=10, y=20

2

nachher: x=20, y=10

und mit Multiplikation/Division ;-)

1

    int x=10;

2

    int y=20;

3

    printf("vorher: x=%d, y=%d\n", x,y);

4

5

    x=x*y;

6

    y=x/y;

7

    x=x/y;

8

9

    printf("nachher: x=%d, y=%d\n", x,y);

Jemand schrieb:
> mh schrieb:
>> Was ist die raw integer representation eines floats?
>
> Das, was du bekommst, wenn du per Union eine Gleitkommazahl als Integer
> interpretierst.
Soweit ich das sehe ist das legal, wenn man einen unsigned int 
passender Größe nimmt. Interessant.


Sebastian schrieb:
> Warum nimmst du nicht die am einfachsten zu verstehende Lösung, bei der
> du noch hoffen kannst dass auch der Compiler versteht was du willst,
> weil er das Muster erkennt (mit Zwischenspeichern) und läßt den Compiler
> optimieren?
Ich weiß nicht, was der Anlass für diese Frage ist, aber es gibt Fälle 
in denen diese Art der Optimierung notwendig ist, um Register 
einzusparen.

zitter_ned_aso schrieb:
> Und wenn die Variablen Strings sind? Oder struct-Variablen?
2 unsigned char* + Schleife

mh schrieb:
> aber es gibt Fälle
> in denen diese Art der Optimierung notwendig ist, um Register
> einzusparen.

Ich denke mal, das braucht mehr Register (4?) als das simple Swap (3) 
(angenommen der Item passt in ein Register).
Warum das herumgeistert ist wohl nur wegen unbekannt und erstaunlich 
Effekten.

leo

Rolf M. schrieb:
>> Ich denke mal, das braucht mehr Register (4?) als das simple Swap (3)
>
> Wofür sollten so viele Register nötig sein?

Ja, sorry - da hab ich wohl geirrt.

leo

Rolf M. schrieb:
> Nein, man darf immer nur auf das Union-Element zugreifen, das "aktiv"
> ist, und das ist das zuletzt geschriebene.

C11 erlaubt das.

6.5.2.3 Structure and union members:

1

95) If the member used to read the contents of a union object is not the same as the member last used to store a value in the object, the appropriate part of the object representation of the value is reinterpreted as an object representation in the new type as described in 6.2.6 (a process sometimes called "type punning"). This might be a trap representation.

Rolf M. schrieb:
> Nein, man darf immer nur auf das Union-Element zugreifen, das "aktiv"
> ist, und das ist das zuletzt geschriebene.

In C erlaubt in C++ verboten (mit Ausnahmem)

tja, dann wollt ihr Strings in irgendwelchen Schleifen durchlaufen.

Also kommt eine Laufvariable zum Einsatz. Man hat also doch eine 
zusätzliche Variable.

ja, stimmt. man kann alles per Hand machen

1

    char str1[10]="hallo";

2

    char str2[10]="welt";

3

4

    printf("vorher: %s %s\n", str1, str2);

5

6

    *str1^=*str2;

7

    *str2^=*str1;

8

    *str1^=*str2;

9

10

    printf("1. Durchgang: %s %s\n", str1, str2);

11

12

    *(str1+1)^=*(str2+1);

13

    *(str2+1)^=*(str1+1);

14

    *(str1+1)^=*(str2+1);

15

16

    printf("2. Durchgang: %s %s\n", str1, str2);

17

18

    //usw...

lol

Walter K. schrieb:
> Gibt es noch andere Lösungen um den Inhalt ohne Zwischenspeichern
> zu tauschen?
>
> #include<stdio.h>
>
> int main()
> {
>    int x=10;   int y=25;
>
>    x ^= y; y ^= x; x ^= y;
>
>    printf("\n x = %i   y = %i ", x, y);
> }

Bester Tipp: Lass den Quatsch, das ist nicht effizienter. Zweitbester 
Tipp: Was passiert denn wenn x und y identisch sind (im Sinne identische 
Variable wenn du das Konstrukt später als Makro oder inline Funktion 
verpackt hast)?

1

x = y = 42;

2

 -> x ^= y;

3

 -> x = x ^ y;

4

 -> x = x ^ x;

5

 -> x = 0

zitter_ned_aso schrieb:
> Hier, mal ganz was erstaunliches ;-)

ja ;-)
Hanns schrieb:
> In
> [[https://graphics.stanford.edu/~seander/bithacks.html#SwappingValuesSubAdd]]
> wird es mit Addition und Subtraktion gezeigt.

Wobei XOR ja auch eine Addition ist, nur halt Bitweise und man nicht 
zwischen Addition und Subtraktion unterscheiden muss (daher beides mal 
XOR nehmen kann).

x^y schrieb:
> Walter K. schrieb:
>> Gibt es noch andere Lösungen um den Inhalt ohne Zwischenspeichern
>> zu tauschen?
>>
>> #include<stdio.h>
>>
>> int main()
>> {
>>    int x=10;   int y=25;
>>
>>    x ^= y; y ^= x; x ^= y;
>>
>>    printf("\n x = %i   y = %i ", x, y);
>> }
>
> Bester Tipp: Lass den Quatsch, das ist nicht effizienter. Zweitbester
> Tipp: Was passiert denn wenn x und y identisch sind (im Sinne identische
> Variable wenn du das Konstrukt später als Makro oder inline Funktion
> verpackt hast)?
> x = y = 42;
>  -> x ^= y;
>  -> x = x ^ y;
>  -> x = x ^ x;
>  -> x = 0

Leider seh ich nicht was Du genau meinst. Vielleicht liegt es auch an 
der Optimierung des GCC, allerdings glaube ich das (noch) nicht.

#include<stdio.h>

1

int main()

2

{

3

   int x=25;   int y=25;

4

5

   printf("\n x = %i   y = %i ", x, y);

6

7

   x ^= y; // x=0

8

9

   printf("\n x = %i   y = %i ", x, y);

10

11

   y ^= x; // y=25

12

13

   printf("\n x = %i   y = %i ", x, y);

14

15

   x ^= y; // x=25

16

17

   printf("\n x = %i   y = %i ", x, y);

18

}

1

% ./a.out 

2

3

 x = 25   y = 25 

4

 x = 0   y = 25 

5

 x = 0   y = 25 

6

 x = 25   y = 25

Niklas G. schrieb:
> [K]ein Sohn [des] Admins (frei nach Lk 3,33) schrieb im Beitrag
> #5797110:
>> Leider seh ich nicht was Du genau meinst
>
> Sollte man auf die Idee kommen das Tauschen (hässlich) in ein Makro zu
> packen:
> #define UINT_SWAP(x,y) do { (x) ^= (y); (y) ^= (x); (x) ^= (y); } while
> (0)

Danke, jetz seh ichs auch.