Was ist der effizienteste Weg, um eine kurze Zeichenfolge in eine 32-Bit-Ganzzahl zu konvertieren?

Question

Für viele Zwecke sind kurze Strings/Char-Arrays, die in eine vorzeichenlose 32-Bit-Ganzzahl gepackt sind, ziemlich nützlich, da sie auf einen Schlag mit einem einfachen Ganzzahlvergleich verglichen und in switch-Anweisungen verwendet werden können Lesbarkeit.

Der häufigste Weg, um diese kurzen Strings zu 32-Bit-Integer zu konvertieren ist zu verschieben/oder:

#include <stdint.h> 

uint32_t quadchar(const char* _str) 
{ 

    uint32_t result = 0; 

    for(size_t i=0; i<4; i++) 
    { 
     if(_str[i] == 0) 
      return result; 
     result = (result << 8) | _str[i]; 
    } 

    return result; 
} 

Strings, die zu lang sind, wird abgeschnitten.

So weit so gut, aber das muss zur Laufzeit gemacht werden, was ein bisschen Zeit kostet. Wäre es auch möglich, dies zur Kompilierzeit zu tun?

Answer 1

Ab C++ 11 ist es möglich, dies zur Kompilierungszeit ohne Kosten zur Laufzeit unter Verwendung der constexpr specifier zu tun.

namespace Internal 
{ 
    uint32_t inline constexpr quadchar(char const *_input, 
     uint8_t _idx, uint32_t _result) 
    { 
     return _idx == 4 ? _result 
      : *_input ? quadchar (_input+1, _idx + 1, (_result << 8) | *_input) 
       : _result; 
    } 
} 

uint32_t inline constexpr quadchar(char const *_input) { 
    return Internal::quadchar(_input, 0, 0); 
} 

Ich habe die Implementierungsüberladung in einen internen Namespace platziert, um sie vor dem Benutzer zu verbergen. Die Syntax ist nicht so gut wie im obigen Laufzeitbeispiel, da Sie if in constexpr nicht verwenden können, aber ich denke, es ist es wert.

Answer 2

Es ist keine detaillierte Hilfsfunktion erforderlich: Sie können Standardwerte verwenden.

Und es gibt keine Notwendigkeit für eine Doppel ternären Operator: Sie alle mit einem einzigen Test machen

std::uint32_t inline constexpr quadchar (char const * input, 
             std::size_t idx = 0U, 
             std::uint32_t result = 0U) 
{ 
    return (idx < 4U) && *input 
     ? quadchar(input+1, idx+1U, (result << 8) | *input) 
     : result; 
} 

Aber es ist ein wenig mehr tragbar und Generika zu machen, schlage ich vor,

1) verwenden sizeof() statt 4 für die idx Grenze

2) verwenden CHAR_BIT statt 8 für die result Verschiebung (remember "enthalten")

3) Verwenden Sie einen Vorlagetyp (standardmäßig std::uint32_t, wenn Sie möchten) für den Typ result.

So etwas wie

template <typename I = std::uint32_t> 
constexpr inline I ichar (char const * input, 
          I result = 0U, 
          std::size_t idx = 0U) 
{ 
    return (idx < sizeof(I)) && *input 
     ? ichar(input+1, idx+1U, (result << CHAR_BIT) | *input) 
     : result; 
} 

, die Sie

constexpr auto u32 = ichar(ptr); 

aufrufen können, wenn Sie einen std::uint32_t wollen, oder (durch Beispiel)

constexpr auto u64 = ichar<std::uint64_t>(ptr); 

für andere zurück Typen.