c++ - Simple constexpr LookUpTable in C++14 -
i trying make simple lookuptable based on array of integers, idea have calculated @ compile time.
trying make possible use other future tables of various integer types might have, need template.
so have lookuptable.h
#ifndef lookuptable_h #define lookuptable_h #include <stdexcept> // out_of_range template <typename t, std::size_t number_of_elements> class lookuptableindexed { private: //constexpr static std::size_t number_of_elements = n; // lookuptable t m_lut[ number_of_elements ] {}; // essential t default constructor compile-time interpreter! public: // construct , populate lookuptable such that; // indices of values mapped data values stored constexpr lookuptableindexed() : m_lut {} { //ctor } // returns number of values stored constexpr std::size_t size() const {return number_of_elements;} // returns data value @ given index constexpr t& operator[](std::size_t n) { if (n < number_of_elements) return m_lut[n]; else throw std::out_of_range("lookuptableindexed[] : outofrange!"); } constexpr const t& operator[](std::size_t n) const { if (n < number_of_elements) return m_lut[n]; else throw std::out_of_range("lookuptableindexed[] const : outofrange!"); } using iterator = t*; // returns beginning , end of lookuptable constexpr iterator begin() {return &m_lut[0 ];} constexpr iterator end () {return &m_lut[number_of_elements];} }; #endif // lookuptable_h and i'm trying use in class rapid attenuation of integer signal wrt integer distance.
eg. sample usage foo.h
#ifndef foo_h #define foo_h #include <limits> // max, digits #include <stdlib.h> // abs #include "lookuptable.h" // lookuptableindexed class foo { private: template <typename tdistance, tdistance maximum_distance, std::size_t number_of_digits> struct distanceattenuation { private: // maximum value can held in type //constexpr auto maximum_distance = std::numeric_limits<tdistance>::max(); // number of bits used type //constexpr auto number_of_digits = std::numeric_limits<tdistance>::digits; // lookuptable lookuptableindexed<tdistance, number_of_digits> m_attenuationrangeupperlimit {}; // essential lookuptable default constructor compile-time interpreter! // returns number of bits bit-shift-right, attenuate, signal // given distance source constexpr std::size_t attenuateby(const tdistance distance) { (std::size_t {number_of_digits}; (i > 0); --i) { // while distance exceeds upper-limit, keep trying values if (distance >= m_attenuationrangeupperlimit[i - 1]) { // found range given distance occupies return (i - 1); } } throw std::logic_error("distanceattenuation::attenuateby(cannot attenuate signal using given distance!)"); } public: // calculate distance correction factors signals // can attenuated emulate the effects of distance on signal strength // ...using inverse square relationship of distance signal strength constexpr distanceattenuation() : m_attenuationrangeupperlimit {} { //ctor // populate lookuptable (std::size_t {0}; (i < number_of_digits); ++i) { tdistance goo = 0; // not attenuation calculation tdistance hoo = 0; // **for test only!** m_attenuationrangeupperlimit[i] = maximum_distance - goo - hoo; } static_assert((m_attenuationrangeupperlimit[0] == maximum_distance), "distanceattenuation : failed build lut!"); } // attenuate signal, s, effect of distance // factor, a, where; // positive contribution values attenuated down toward 0 // negative 0 constexpr signed int attenuatesignal(const signed int s, const int a) { return (s < 0)? -(abs(s) >> a) : (abs(s) >> a); } constexpr signed int attenuatesignalbydistance(const signed int s, const tdistance d) { return attenuatesignal(s, attenuateby(d)); } }; using sdistance_t = unsigned int; constexpr static auto m_distanceattenuation = distanceattenuation<sdistance_t, std::numeric_limits<sdistance_t>::max(), std::numeric_limits<sdistance_t>::digits>(); public: foo() {} ~foo() {} // integer foo signed int attenuatefoo(signed int signal, sdistance_t distance) {return m_distanceattenuation::attenuatesignalbydistance(signal, distance);} }; #endif // foo_h i have tried several ways, using youtube video tutorial cppcon 2015: scott schurr “constexpr: applications" , others, won't compile giving error;
error: 'constexpr static auto m_distanceattenuation...' used before definition and static asserts fail with
error: non-constant condition static assertion indicating isn't calculating @ compile-time.
i'm new c++.
i know i'm doing obvious don't know is.
am misusing static or constexpr?
numeric_limits constexpr?
what doing wrong? thank you.
some observations
1) as observed michalsrb, foo isn't complete when initialize m_distanceattenuation , distanceattenuation part of foo, incomplete.
unfortunately can't initialize static constexpr member incomplete type (as better explained jogojapan in answer).
suggestion: define distanceattenuation outside (and before) foo; it's complete type , can used initialize m_distanceattenuation; like
template <typename tdistance, tdistance maximum_distance, std::size_t number_of_digits> struct distanceattenuation { // ... }; class foo { // ... }; 2) in c++14, constexpr method isn't const method; suggestion: define following method const or can't use in constexpr expressions
constexpr std::size_t attenuateby (const tdistance distance) const constexpr signed int attenuatesignal(const signed int s, const int a) const constexpr signed int attenuatesignalbydistance(const signed int s, const tdistance d) const 3) in attenuateby(), test in following for ever true
for (std::size_t {number_of_digits - 1}; (i >= 0); --i) because std::size_t ever >= 0, for goes in loop , never exit; suggestion: redefine i int or long
4) in attenuatefoo() use m_distanceattenuation variable defined m_distanceattenuation; suggestion: correct che name of variable used
5) in attenuatefoo() call method attenuatesignalbydistance() using :: operator; suggestion: use . operator, (considering point (4) too)
signed int attenuatefoo(signed int signal, sdistance_t distance) {return m_distanceattenuation.attenuatesignalbydistance(signal, distance);} 
Comments
Post a Comment