Leider bin ich in ASM sehr schwach, deshalb kann ich mir selbst kein Bild machen.

Ich möchte sehr oft zwei Bytes mit zwei Bytes vergleichen:

unsigned char* data = ...

// Compare-Funktion
bool SomeClass::Compare(const unsigned char* bytes)
{
    return (this->bytes[0] == bytes[0] && this->bytes[1] == bytes[1]);
}

// Aufruf, sehr oft
if(obj->Compare(data))
// ...

Nun, einfacher wäre es aber, der Compare-Funktion short zu übergeben, allerdings müsste ich dann immer Casten. Wie kostspielig ist das?
Sollte doch eigentlich egal sein, es wird ja nur anders interpretiert, nicht?
Und ein Vergleich fällt dann auch weg:

// Ist das teurer?

unsigned char* data = ...

// Compare-Funktion
bool SomeClass::Compare(unsigned short shortVal)
{
    return (this->shortVal == shortVal);
}

// Aufruf, sehr oft
if(obj->Compare(*reinterpret_cast<unsigned short*>(data)))
// ...

Ist vielleicht etwas Mikrooptimierung, aber es ist nur wenig Code und der sollte so performant wie nur möglich sein.

Anmerkung: Ich programmiere nur für Windows, daher ist diese Casterei problemlos. Es wird immer little endian sein.

Danke!
MfG

allerdings kann es natürlich sein, dass der compiler dein konstrukt erkennt
und entsprechend optimiert.

anstatt zu sagen: "teste es", sag ich einfach mal es ist schneller, zumindestens
unoptimiert.

tipp:
caste in der funktion (einmal), das erspart das casten beim aufrufen (oft).

bool SomeClass::Compare(const unsigned char* bytes)
{
    return *reinterpret_cast<unsigned short*>(bytes) ==
           *reinterpret_cast<unsigned short*>(this->bytes);
}

dann brauchst du beim Aufruf nicht zu casten:

if(obj->Compare(data))
  ...