C++力模板参数

Question

我希望这段代码是可能的。

template<typename K, typename T, typename Comparer>
class AVLTree
{
   ...
   void foo() {
       ...
       int res = Comparer::compare(key1, key2);
       ...
   }
   ...
};

具体来说，我想强制 Comparer 类具有 static int Compare(K key1, K key2) 函数。我正在考虑使用推导，但找不到任何可以使用模板的想法。

谢谢。

Answer 1

你不能。但是，如果使用该函数而比较器没有它，您的编译将失败，这或多或少是您想要发生的情况。是的，就像其他人指出的那样，您想将静态称为静态。

Answer 2

您是否尝试这样做：

   int res = Comparer::compare(key1, key2);

在 C++ 中，静态函数可以通过两种方式调用：

object.static_method(); // use dot operator

classname::static_method(); // use scope resolution operator

Answer 3

Michael 已经提到如果 Comparer 没有所需的成员函数。

但是，如果您更担心简洁的错误消息，请使用类似 this 来检测类是否具有必需的成员函数并将其与诸如 Boost.StaticAssert：

template<typename K, typename T, typename Comparer>
class AVLTree
{
    BOOST_STATIC_ASSERT(HasCompareMethod<Comparer>::has);
    //...
};

Answer 4

它必须是Comparer::Compare，对吧？ （因为您正在调用类型上的静态函数）。

您的 Comparer 类必须定义如下：

template<typename K>
class Comparer
{
public:
    static bool Compare(K key, K key)
    {
        return true;
    }
};

Answer 5

据我了解，您正在寻找更好的错误消息，以防模板参数不符合模板主体的要求。该语言没有内置的特殊机制，但人们使用库来近似它。请参阅 Boost 概念检查

Answer 6

对此进行编译时断言的松散方法是获取 Comparer::compare 的地址并将其分配给声明为 int(K, K) *func 的变量。

如果它是静态函数，则该分配将起作用，但如果它是成员函数，则该分配将不起作用。

我只是贡献这个，但我会采取使用 boost 习语的方法，因为这是手工制作的，可以这么说。

Answer 7

这是一种更惯用和通用的方法：

template<typename K, typename T>
class AVLTree
{
   ...
   template <typename Comparer>
   void foo(Comparer cmp) {
       ...
       int res = cmp(key1, key2);
       ...
   }
   ...
};

Comparer 不应该是定义静态 Compare 方法的类型。它应该是一个可以用函数调用语法调用的类型。这允许您使用函数对象的函数指针，并且允许您重用标准库中或几乎任何其他重要的 C++ 应用程序中已定义的比较器。它允许您在 C++0x 中添加 lambda 时使用它们。

至于强制 Comparer 按预期行事？ int res = cmp(key1, key2); 行已经确保了这一点。如果尝试传递无法以这种方式调用的类型，则会出现编译错误。

您的原始代码中的情况也是如此。如果您传递的类型没有静态 Compare 方法，则会出现编译错误。所以你原来的代码已经解决了这个问题。

Answer 8

正如已经指出的，您不能强制 Compare 有一个静态成员 compare。如果您的比较器没有实现它，您只会收到编译器错误。

如果你像这样实现AVLTree，那么将Comparer声明为模板模板参数会更优雅：

template <typename K>
class DefaultComparer
{
public:
    static bool compare(K k1, K k2)
    { return k1 == k2; }
};

template <typename K>
class MyComparer : public DefaultComparer<K>
{
public:
    static bool compare(K k1, K k2)
    { return k1 <= k2; }
};

template <typename K>
class InvalidComparer
{
public:
    static bool bar(K k1, K k2)
    { return k1 != k2; }
    // Doesn't implement compare()
};

// Compare is a template template paramenter with default template argument
// DefaultComparer
template <typename K, template <typename K> class Comparer = DefaultComparer>
class AVLTree
{
    K k1, k2;
public:
    AVLTree() : k1(0), k2(0) { } // ctor
    bool foo();
};

// Definiton of AVLTree::foo()
template <typename K, template <typename K> class Comparer>
bool AVLTree<K, Comparer>::foo()
{
    return Comparer<K>::compare(k1, k2);
}

int main(int argc, char *argv[])
{
    // Without template template parameters you 
    // would have to use AVLTree<int, DefaultComparer<int> >
    AVLTree<int> avltree;

    // instead of AVLTree<int, MyCompare<int> >
    AVLTree<int, MyComparer> avltree2;

    // Calling foo() will generate a compile error. 
    // But if you never call avltree3.foo() this will compile!
    AVLTree<int, InvalidComparer> avltree3;

    avltree.foo(); // calls DefaultComparer::compare
    avltree2.foo(); // calls MyComparer::compare
    avltree3.foo(); // fails to compile
}

请参阅：http://codepad.org/OLhIPjed