8

对于模板参数给定的类型，C++ 有某种类型的鸭子类型。我们不知道类型DUCK1和DUCK2将是什么，但只要它们可以quack()，它将编译并运行：

template <class DUCK1, class DUCK2>
void let_them_quack(DUCK1* donald, DUCK2* daisy){
  donald->quack();
  daisy->quack();
}

但是写起来有点不方便。当我完全不关心实际类型是什么DUCK1，DUCK2而是想充分利用鸭子类型的想法时，我想要一些与上面略有不同的东西：

  1. 我想省略编写一个重复且几乎没有意义的模板参数列表（想象一下如果有 7 只鸭子会发生什么......）
  2. 我想更明确一点，从不使用类型，并且只有接口才是重要的。
  3. 我想要某种接口注释/检查。以某种方式明确类型背后的预期接口。（然而，这与鸭子打字有点不同。）

C++ 是否提供任何功能来实现这 3 个想法中的一个或多个？

（我知道在大多数情况下，虚拟继承是实现此类模式的首选方法，但这里的问题专门针对静态多态的情况。）

4

5 回答 5

11

关于问题 1 和 2：从 C++14 开始，您可以省略显式template <typename ...样板和 use auto，但仅限于 lambda：

auto let_them_quack = [] (auto & donald, auto & daisy){
    donald.quack();
    daisy.quack();
};

（是的，我更喜欢对指针的引用）。GCC 允许在通常的功能中这样做作为扩展。

对于问题 3，您所说的内容称为概念。它们在 C++ 中存在了很长时间，但只是作为一个文档术语。现在概念 TS正在进行中，允许您编写类似的内容

template<typename T>
concept bool Quackable = requires(T a) {
    a.quack();
};

void let_them_quack (Quackable & donald, Quackable & daisy);

请注意，它还不是 C++，只是一个正在进行中的技术规范。不过，GCC 6.1 似乎已经支持它。使用当前 C++ 实现概念和约束是可能的；你可以在boost中找到一个。

于 2016-04-27T12:59:38.460 回答
5

我想省略编写一个重复且几乎没有意义的模板参数列表（想象一下如果有 7 只鸭子会发生什么......）

为此，您可以使用可变参数模板并执行以下操作：

template<typename DUCK>
void let_them_quack(DUCK &&d) {
  d.quack();
}

template<typename DUCK, typename... Args>
void let_them_quack(DUCK &&d, Args&& ...args) {
  d.quack();
  let_them_quack(std::forward<Args>(args)...);
}

现场演示

于 2016-04-27T12:59:18.633 回答
1

如果给定的类没有实现接口，代码将无法编译并引发编译错误，因此 #2 和 #3 有点受到关注。你也可以使这个正式：

class duck {

public:
   virtual void quack()=0;
};

然后将函数的参数声明为指向鸭子的指针。您的类将必须从此类继承，从而使要求let_them_quack()一目了然。

就＃1而言，可变参数模板可以解决这个问题。

void let_them_quack()
{
}

template <typename ...Args>
void let_them_quack(duck* first_duck, Args && ...args) {
  first_duck->quack();
  let_them_quack(std::forward<Args>(args)...);
}
于 2016-04-27T13:01:22.237 回答
1

您将能够通过概念使其看起来更漂亮（尚未成为标准 - 但非常接近）：

http://melpon.org/wandbox/permlink/Vjy2U6BPbsTuSK3u

#include <iostream>

template<typename T>concept bool ItQuacks(){
    return requires (T a) {
        { a.quack() } -> void;
    };
}

void let_them_quack2(ItQuacks* donald, ItQuacks* daisy){
  donald->quack();
  daisy->quack();
}

struct DisneyDuck {
    void quack(){ std::cout << "Quack!";}
};

struct RegularDuck {
    void quack(){ std::cout << "Quack2!";}
};

struct Wolf {
    void woof(){ std::cout << "Woof!";}
};

int main() {
    DisneyDuck q1, q2;
    let_them_quack2(&q1, &q2);

    RegularDuck q3, q4;
    let_them_quack2(&q3, &q4);    

    //Wolf w1, w2;
    //let_them_quack2(&w1, &w2);    // ERROR: constraints not satisfied
}

输出：

 Quack!Quack!Quack2!Quack2!

omit writing a template parameter list如您所见，您types are never used and that it's only the interface that matters将能够：这I'd like to have sort of an interface annotation/check.也会发生，概念使用也会给你有意义的错误信息。

于 2016-04-27T13:18:42.330 回答
0

我们只需要编写一个版本的函数：

#include <utility>

template<typename... Quackers>
void let_them_quack(Quackers&& ...quackers) {
  using expand = int[];

  void(expand { 0, (std::forward<Quackers>(quackers).quack(), 0)... });
}

struct Duck {
  void quack() {}
};

int main()
{
  Duck a, b, c;
  let_them_quack(a, b, c, Duck());
}
于 2016-04-27T15:45:19.537 回答