将成员函数从基类移动到派生类会无缘无故地破坏程序

Question

这个（虚构的）问题最初被表述为一个谜题，隐藏 一些可能有助于更快地发现问题的细节。向下滚动 对于更简单的MCVE 版本。

---

原始（拼图）版本

我有这段代码输出0：

#include <iostream>
#include <regex>

using namespace std;

regex sig_regex("[0-9]+");
bool oldmode = false;

template<class T>
struct B
{
    T bitset;

    explicit B(T flags) : bitset(flags) {}

    bool foo(T n, string s)
    {
        return bitset < 32                   // The mouth is not full of teeth
               && 63 > (~n & 255) == oldmode // Fooness holds
               && regex_match(s, sig_regex); // Signature matches
    }
};

template<class T>
struct D : B<T>
{
    D(T flags) : B<T>(flags) {}

};

int main()
{
    D<uint64_t> d(128 | 16 | 1);
    cout << d.foo(7, "123") << endl;
}

但是，当我将函数 foo() 从 B 移动到 D 时，它开始输出 1 (proof is on Coliru)。

为什么会这样？

---

MCVE 版本

Live on Coliru

#include <iostream>
#include <bitset>

using namespace std;

template<class T>
struct B
{
    T bitset{0};

    bool foo(int x)
    {
        return bitset < 32 && 63 > (x + 1) == x % 2;
    }
};

template<class T>
struct D : B<T>
{
    bool bar(int x) // This is identical to B<T>::foo()
    {
        return bitset < 32 && 63 > (x + 1) == x % 2;
    }
};

int main()
{
    D<uint64_t> d;
    cout << d.foo(1) << endl; // outputs 1
    cout << d.bar(1) << endl; // outputs 0; So how is bar() different from foo()?
}

Answer 1

是的，因为bitset会被解释为非依赖名，并且有一个名为std::bitset<T>的模板，所以会被解析为：

template<class T>
struct D : B<T>
{
    D(T flags) : B<T>(flags) {}
    bool foo(T n, string s)
    {
        return ((std::bitset < 32  && 63 > (~n & 255)) == oldmode)
               && regex_match(s, sig_regex);
    }
};

你需要这样做：

template<class T>
struct D : B<T>
{
    D(T flags) : B<T>(flags) {}

    bool foo(T n, string s)
    {
        // or return B<T>::bitset
        return (this->B<T>::bitset < 32)                   // The mouth is not full of teeth
               && 63 > (~n & 255) == oldmode // Fooness holds
               && regex_match(s, sig_regex); // Signature matches
    }
};

或者更好，不要使用using namespace std;

Answer 2

这是一个非常酷的例子！！！ :)

我认为 - 发生的事情是这样的：

bitset < 32 && 63 >(~n & 255)

被解析为bitset

Answer 3

1. 为什么会这样？

对于派生类，B<T>不是非依赖基类，不知道模板参数是无法确定的。而bitset 是一个非依赖名称，不会在依赖基类中查找。相反，这里使用了std::bitset（因为using namespace std;）。所以你会得到：

return std::bitset<32 && 63>(~n & 255) == oldmode
       && regex_match(s, sig_regex);

您可以使名称 bitset 依赖；因为依赖名称只能在实例化时查找，并且那时必须探索的确切基础特化将是已知的。例如：

return this->bitset < 32                   // The mouth is not full of teeth
//     ~~~~~~
       && 63 > (~n & 255) == oldmode       // Fooness holds
       && regex_match(s, sig_regex);       // Signature matches

或

return B<T>::bitset < 32                   // The mouth is not full of teeth
//     ~~~~~~
       && 63 > (~n & 255) == oldmode       // Fooness holds
       && regex_match(s, sig_regex);       // Signature matches

或

using B<T>::bitset;
return bitset < 32                   // The mouth is not full of teeth
       && 63 > (~n & 255) == oldmode // Fooness holds
       && regex_match(s, sig_regex); // Signature matches

1. 回答完这个问题后，标题应该是什么？

"如何访问模板基类中的非依赖名称？"

Answer 4

这就是为什么你永远不应该using namespace std;

bool foo(T n, string s)
{
    return bitset < 32                  
           && 63 > (~n & 255) == oldmode 
           && regex_match(s, sig_regex);
}

bitset 不是你想的那样。因为B<T> 是一个从属基类，所以对非限定查找隐藏了成员。所以要访问bitset，你需要通过this¹来访问它，或者明确限定它（更多细节见here）：

(this->bitset)
B<T>::bitset

因为bitset 在派生的情况下没有命名B<T>::bitset，这意味着什么？好吧，因为你写了using namespace std;，它实际上是std::bitset，而你的表达式的其余部分恰好是有效的。以下是发生的事情：

bool foo(T n, string s)
{
    return std::bitset<32 && 63>(~n & 255) == oldmode 
           && regex_match(s, sig_regex);
}

32 && 63 的计算结果为 true，对于 std::bitset 模板参数，它被提升为 1u。这个std::bitset 用~n & 255 初始化，并用oldmode 检查是否相等。最后一步是有效的，因为std::bitset 有一个非显式构造函数，它允许从oldmode 构造一个临时的std::bitset<1>。

---

¹ 请注意，在这种情况下，由于一些非常微妙的解析消歧规则，我们需要用括号括起来 this->bitset。详情请见Template dependent base member is not resolved properly。