Статическая утиная типизация на C ++

Относительно вопросов 1 и 2: начиная с C ++ 14 вы можете опустить явный шаблон template <typename ... и использовать auto, но только в лямбдах:

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

(да, предпочитаю ссылки на указатели). GCC позволяет делать это в обычных функциях в качестве расширения.

Что касается вопроса 3, то то, о чем вы говорите, называется концепциями. Они существовали в C ++ давно, но только как документальный термин. Сейчас выполняется Concepts 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.

Я бы не хотел писать повторяющийся и бессмысленный список параметров шаблона (только представьте, что произойдет, если будет 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)...);
}

Живая демонстрация

# 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)...);
}

Вы сможете сделать его более красивым с помощью концепции (пока не в стандарте, но очень близко):

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, ItQuacks довольно явный, поэтому types are never used and that it's only the interface that matters имеет место. Это I'd like to have sort of an interface annotation/check. тоже имеет место, использование концепции также даст вам содержательное сообщение об ошибке.

Нам нужно написать только одну версию функции:

#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());
}