erzeugen, um die Elementwerte eines konstanten Array von Integer-Logarithmen

Question

Ich kann dieses Stück Code in C geschrieben scheinen zu verstehen, ++:

static const char LogTable256[256] = 
{ 
#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n 
-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 
LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6), 
LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7) 
}; 

wie kann ich das gleiche Array mit Schleifen erzeugen?

Answer 1

#define Zeilen können überall in Ihrem Code vorkommen, solange ihre Verwendung ihnen folgt. Da sie Präprozessordirektiven sind, gibt es keinen Unterschied zwischen ist:

static const char LogTable256[256] = 
{ 
#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n 
-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 
LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6), 
LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7) 
}; 

und

#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n 

static const char LogTable256[256] = 
{ 
-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 
LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6), 
LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7) 
}; 

Wenn die zweite Sie sinnvoll ist, dann sicher sein, dass die erste wie die so weit ist nur so gut Compiler und Verhalten des Programms betroffen ist. Der erste könnte menschliche Leser dazu verleiten zu denken, dass das Makro im Bereich der Deklaration der Variablen definiert ist, was nicht wahr ist.

Answer 2

Wie kann ich das gleiche Array mit Schleifen erzeugen?

Sie können das nicht mit Schleifen tun, weil das char-Array const ist.

Was der Algorithmus tut, ist, füllt es ein Char-Array mit Zahlen von -1 bis 7, wobei, beginnend bei 1, jede Zahl doppelt so oft wie die vorher eingegeben wird. Dies kann mit zwei einfachen verschachtelten Schleifen oder einer Schleife, pow und memset erfolgen. Damit das funktioniert, darf das char-Array nicht const sein.

Answer 3

Die Position der #define Präprozessordirektive nicht technisch außer egal, dass es Makro Verwendung der LT kommt vor, dass es definiert. Herkömmliche Formatierung würde es vor der Array-Definition platzieren. Es ist nicht auf den Bereich beschränkt, in dem es definiert ist: Makros respektieren keine Bereiche.

Um das Array ohne Verwendung eines Makros zu definieren, können Sie ein Singleton verwenden, z. B. ein Meyers Singleton.

Einmalige Initialisierung der Job eines Konstruktor ist, das ist so, wie ich es tun würde, ein Singleton Meyers mit einem Objektklasse Typ, dessen Konstruktor berechnet die Array-Elementwerte:

auto logarithms() 
    -> std::array<signed char, 256> const& 
{ 
    struct Wrapper 
    { 
     std::array<signed char, 256> items_; 

     static void append(int const n, int const value, signed char*& p) 
     { 
      for(int i = 1; i <= n; ++i) { *p++ = value; } 
     } 

     Wrapper() 
     { 
      items_[0] = -1; 
      signed char* p = &items_[1]; 
      for(int i = 0; i < 8; ++i) { append(1 << i, i, p); } 
      assert(p == &*items_.end()); 
     } 
    }; 

    static Wrapper const the_array; 
    return the_array.items_; 
} 

Hinweis des Verwendung von expliziten signed char: der Typ char ist nicht garantiert signiert werden, dh in der Lage sein, dass -1 Wert darstellen.

Jedoch wird in Berechnungen jeder signed char Wert gefördert und das kann beeinträchtigen, anstatt die Effizienz zu verbessern. Die Verwendung von signed char ist auch nur eine Komplikation. Wenn dies nicht für ein eingebettetes System mit extrem wenig verfügbarem Speicher ist, würde ich nur int anstelle von signed char verwenden.

Answer 4

Sie können sogar constexpr verwenden, die aufgerufen werden kann, wenn ein constexpr Objekt initialisiert wird. Füllen Arrays ist möglich, aber std::array fehlt einige constexpr Deklarationen, die mit C++17 eingeführt werden.Im Moment müssen wir auf ein einfaches Array zurückgreifen und dieses dann in eine mit einer Hilfsfunktion to_array konvertieren, die auch zum Standard/tr2 hinzugefügt wird.

#include <array> 
#include <algorithm> 
#include <cassert> 

// this is from cppreference 

namespace detail { 
template <class T, std::size_t N, std::size_t... I> 
constexpr std::array<std::remove_cv_t<T>, N> 
    to_array_impl(T (&a)[N], std::index_sequence<I...>) 
{ 
    return { {a[I]...} }; 
} 
} 

template <class T, std::size_t N> 
constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) 
{ 
    return detail::to_array_impl(a, std::make_index_sequence<N>{}); 
} 

constexpr auto make() 
{ 
    int a[256] = {-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,}; 

    for(size_t i=4, n=16, start=16; i <= 7; ++i, n *= 2) 
    { 
     for(size_t j=0; j != n; ++j) 
     { 
      a[start + j] = i; 
     } 

     start += n; 
    } 

    return to_array(a); 
} 

int main() { 
    static const int LogTable256[256] = 
{ 
#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n 
-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 
LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6), 
LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7) 
}; 

    auto constexpr a = make(); 
    assert(std::equal(std::begin(a), std::end(a), std::begin(LogTable256)));  
    return 0; 
} 

auto constexpr a = make() stellt sicher, dass die Tabelle kompiliert Zeitwert ist. A auto const a = make() funktioniert auch, aber möglicherweise nicht zur Kompilierzeit ausgewertet.

Eine einfachere Implementierung besteht darin, eine Klasse mit einem costexpr-Konstruktor zu verwenden, der die Tabelle enthält. Die Berechnung ist vollständig kompiliert.

class LogTable 
{ 
public: 
    constexpr LogTable() 
    { 
     for(size_t i=4, n=16, start=16; i <= 7; ++i, n *= 2) 
     { 
      for(size_t j=0; j != n; ++j) 
      { 
       a[start + j] = i; 
      } 

      start += n; 
     } 
    } 

    constexpr int operator[](size_t i) const 
    { 
     return a[i]; 
    } 
private: 
    int a[256] = {-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,}; 
}; 

int main() { 
    static const int LogTable256[256] = 
    { 
    #define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n 
    -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 
    LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6), 
    LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7) 
    }; 

    LogTable constexpr l; 
    for(auto i=0; i != 256; ++i) 
    { 
     assert(LogTable256[i] == l[i]); 
    } 

    return 0; 
}