C++ XOR swap on float values ​​

Question

Возможно ли использовать алгоритм замены XOR с поплавковыми значениями в C++?

Однако википедия говорит, что:

XOR операции побитовое поменять значения различных переменных, имеющих один и тот же тип данных

, но я немного запутался. С помощью этого кода:

void xorSwap (int* x, int* y) { 
    *x ^= *y; 
    *y ^= *x; 
    *x ^= *y; 
} 

int main() { 

    float a = 255.33333f; 
    float b = 0.123023f; 
    xorSwap(reinterpret_cast<int*>(&a), reinterpret_cast<int*>(&b)); 
    std::cout << a << ", " << b << "\n"; 

    return 0; 
} 

это, кажется, работает (по крайней мере в ССЗ), но я обеспокоен, если такая практика допускается, если это необходимо?

Answer 1

Технически, что вы просите , возможно, но, как ясно прокомментировал IInspectable, он вызывает неопределенное поведение.
В любом случае, я предлагаю вам вместо этого использовать std::swap, это шаблон, который часто специализируется на определенных типах данных и предназначен для хорошей работы.

Answer 2

Если int такого же размера, как float, он будет работать на практике по любой разумной архитектуре. Память в поплавке представляет собой набор бит, вы интерпретируете эти биты и полностью их заменяете с помощью операций xor. Затем вы можете использовать эти биты как правильные float. Цитата, на которую вы ссылаетесь, говорит только о том, что два значения, которые вы меняете, должны быть одного типа, а оба - int.

Однако на некоторых архитектурах это может привести к перемещению между различными типами регистров или явным сбросом регистров в память. То, что вы увидите практически на любой разумной архитектуре с использованием разумного оптимизирующего компилятора в наши дни, заключается в том, что явный обмен, используя std::swap или выражение с временной переменной, на самом деле быстрее.

I.e. Вы должны написать:

float a = 255.33333f; 
float b = 0.123023f; 
float tmp = a; 
a = b; 
b = tmp; 

или предпочтительно:

float a = 255.33333f; 
float b = 0.123023f; 
std::swap(a,b); 

Если стандартная библиотека автор для вашей архитектуры определил XOR подкачки быть действительно полезными, то вы должны надеяться, что последняя форма будет использовать его. xor swapping - типичная плохая идиома с точки зрения скрытия намерений в тайной тайной реализации. Это было только когда-либо эффективно в серьезных регистрах с голоду с плохими оптимизаторами.

Answer 3

Ваш код вызывает неопределенное поведение. В C или C++ не разрешено приводить float* в int* и использовать его как таковой. reinterpret_cast следует использовать для преобразования между несвязанными структурами с совместимыми макетами или для временного преобразования между типизированным указателем и void*.

О, и в данном конкретном случае УБ не является просто академической проблемой. Компилятор может заметить, что xorSwap() не касается каких-либо float, выполнив оптимизацию, разрешенную им правилами псевдонимов языка, и распечатайте исходные значения a и b вместо измененных значений. И это даже не входит в архитектуры, где int и float имеют разные размеры или выравнивания.

Если вы хотите сделать это безопасно, у вас должно быть memcpy() из ваших поплавков в неподписанные массивы символов, выполните XOR в цикле, затем memcpy() назад. Это, конечно же, сделает операцию медленнее обычной замены. Конечно, обмен на основе xor УЖЕ медленнее, чем обычная замена.

Answer 4

Это:

а) возможно, когда компилятор позволяет.

б) операция, для которой стандарт не определяет поведение (т.е. не определено поведение)

с) на ССЗ, на самом деле менее эффективны, чем о том, что именно вы хотите:

Дано:

void xorSwap (unsigned int* x, unsigned int* y) { 
    *x ^= *y; 
    *y ^= *x; 
    *x ^= *y; 
} 

void swapit3(float& a, float&b) 
{ 
    xorSwap(reinterpret_cast<unsigned int*>(&a), reinterpret_cast<unsigned int*>(&b)); 
} 

результаты в этом:

swapit3(float&, float&):       # @swapit3(float&, float&) 
     mov  eax, dword ptr [rdi] 
     xor  eax, dword ptr [rsi] 
     mov  dword ptr [rdi], eax 
     xor  eax, dword ptr [rsi] 
     mov  dword ptr [rsi], eax 
     xor  dword ptr [rdi], eax 
     ret 

тогда как это:

void swapit2(float& a, float&b) 
{ 
    std::swap(a,b); 
} 

результаты в этом:

swapit2(float&, float&):       # @swapit2(float&, float&) 
     mov  eax, dword ptr [rdi] 
     mov  ecx, dword ptr [rsi] 
     mov  dword ptr [rdi], ecx 
     mov  dword ptr [rsi], eax 
     ret 

ссылка: https://godbolt.org/g/K4cazx