C++ 可变模板移除函数逻辑

Question

I've been able to progress further with my variadic template from my previous question . I've now got a new question. In this code example:

#include <iostream>
#include <cstddef>

constexpr std::uint32_t Flag0   = 0x0001;
constexpr std::uint32_t Flag1   = 0x0002;
constexpr std::uint32_t Flag2   = 0x0004;
constexpr std::uint32_t FlagAll = 0xFFFF;

template<std::uint32_t...Cs>
struct flags_tag {constexpr flags_tag(){}; };

template<std::uint32_t...Cs>
struct make_flags{ using type=flags_tag<Cs...>; };
template<std::uint32_t...Cs>
using make_flags_t=typename make_flags<Cs...>::type;

template<std::uint32_t value>
class pValue_t
{
    template<std::uint32_t StateMask, class flags>
    friend class Compound;    
};

template<> class pValue_t<Flag0>
{ 
public:
    pValue_t() : 
        m_pValue0(reinterpret_cast<void*>(0xFFFFFFFF))
    {} 

protected:
    void* m_pValue0;
};

template<> class pValue_t<Flag1>
{ 
public:
    pValue_t() : 
        m_pValue1(reinterpret_cast<void*>(0xDEADBEEF))
    {}

protected:
    void* m_pValue1;
};

template<> class pValue_t<Flag2>
{ 
public: 
    pValue_t() : 
        m_pValue2(reinterpret_cast<void*>(0xCAFEBABE))
    {}

protected:
    void* m_pValue2;
};

template<std::uint32_t StateMask, class flags>
class Compound;

template<std::uint32_t StateMask, std::uint32_t...Cs>
class Compound< StateMask, flags_tag<Cs...> >:
  public pValue_t<Cs>...
{       
public:
    void print()
    { 
        if (IsStateValid(Flag0))
        { 
            std::cout << this->m_pValue0 << '\n';
        }

        if ((StateMask & Flag1) == Flag1)
        {
            std::cout << this->m_pValue1 << '\n';
        }

        // *** THIS IS THE PROBLEM STATEMENT ***
        if (IsStateValid(Flag2))
        {
            std::cout << this->m_pValue2 << '\n';
        }

    }

    static bool IsStateValid(std::uint32_t stateMask)
        { return ((StateMask & stateMask) == stateMask); }

    uint32_t m_stateMask;
};

using my_type = Compound< Flag0 | Flag1, make_flags_t<Flag0, Flag1>>;

int main() {
  my_type test;
  test.print();
}

the print function contains a reference to m_pValue2 , which is valid when the StateMask contains Flag2 .

Now, the compiler is warning that it cannot find m_pValue2 . I would like for the compiler to remove the chunk of code that references m_pValue2 when the StateMask (known at compile time) does not contain Flag2 (when IsStateValid() is false).

The exact error is as follows:

main.cpp: In instantiation of 'void Compound<StateMask, flags_tag<Cs ...> >::print() [with unsigned int StateMask = 3u; unsigned int ...Cs = {1u, 2u}]':
main.cpp:95:18:   required from here
main.cpp:80:27: error: 'class Compound<3u, flags_tag<1u, 2u> >' has no member named 'm_pValue2'
             std::cout << this->m_pValue2 << '\n';

I'm hoping this is possible. In other template programming, I've used IsStateValid() to compile out code segments that don't match the StateMask . I've never tried to compile away a possibly missing member variable, however.

Does anyone have any ideas?

Answer 1

Why it doesn't work

All branches in a function template will be compiled regardless of type. It doesn't matter that IsStateValid(Flag2) would be false at compile time, the body of that if must be valid code. As there is no this->m_pValue2 in that case, this is a hard error.

What can you do to fix it

You need to forward each print flag function to a function template that will either print the value (if it exists) or do nothing (if it doesn't). We can use function overloading to help here, and ensure that the entire function will not be instantiated if there is no such flag. For example:

void print()
{
    printImpl<Flag0>();
    printImpl<Flag1>();
    printImpl<Flag2>();
}

template <uint32_t F>
void printImpl() {
    printImpl<F>(std::is_base_of<pValue_t<F>, Compound>{});
}

template <uint32_t F>
void printImpl(std::true_type ) {
    // we DO have this flag
    pValue_t<F>::print();
}

template <uint32_t F>
void printImpl(std::false_type ) {
    // we do NOT have this flag
    // so do nothing
}

All you need to do at this point is add the appropriate print() seg:

template<> class pValue_t<Flag2>
{ 
public: 
    pValue_t() : 
        m_pValue2(reinterpret_cast<void*>(0xCAFEBABE))
    {}

    void print() {
        std::cout << m_pValue2 << '\n';
    }

protected:
    void* m_pValue2;
};

Answer 2

I got this to work ( working example ), but it seems very hacky. It shows that it's possible - hopefully a more experienced person than I can clean it up.

The idea is to make IsStataValid a constexpr and separate the code in question out into another function, which has two variants. The variant that gets instantiated depends on the compile-time flag:

static constexpr bool IsStateValid(std::uint32_t stateMask)
    { return ((StateMask & stateMask) == stateMask); }

template <typename A = void,
          typename T = typename std::enable_if<IsStateValid(Flag2), A>::type>
void blub(int x=0) {
    std::cout << this->m_pValue2 << '\n';
}

template <typename A = void, 
          typename T = typename std::enable_if<!IsStateValid(Flag2), A>::type>
void blub(long x=0) {
}

Then instead of the if statement in print() you call the helper function:

blub();

typename A is a dummy parameter to make the enable_if dependent on a template parameter so SFINAE can kick in. The blub s take a first parameter of a different type so the compiler doesn't complain about it not being able to be overloaded.