Pourquoi C++ 1 * nécessite-t-il toujours le mot-clé template au lieu de la frappe complète

Question

Il y a plusieurs années, (au moins pour moi) le polymorphisme C++ statique semblait cohérent. Les langages tels que Python compté sur duck typing, où vous avez:

def fn(foo, bar): 
    foo.baz(bar.bo()) 

et l'idée était que si elle « cancanait » de façon appropriée, il était très bien par la langue.

En C++, à l'inverse, vous auriez à expliquer ce « animal » était:

void fn(foo_type foo, bar_type bar); 

et pour « royaumes de familles », vous auriez besoin explicitement d'utiliser le mot-clé template:

template<class Foo, class Bar> 
void fn(Foo foo, Bar bar); 

---

Avec de nouvelles fonctionnalités comme auto ...() -> decltype types de retour, mais surtout generic lambdas, il semble y avoir quelque chose de beaucoup plus comme non-modèle comme Python du ck frappe:

[] (auto container) { return container.size(); }; 

---

Ma question est donc pourquoi le mot-clé template encore nécessaire? Pourquoi ne pas simplement embrasser pleinement (en option) canard tapant:

// Takes a foo_type and a bar_type 
void fn(foo_type foo, bar_type bar); 

// Takes some "foo-quacking" type, and a bar_type 
void fn(auto foo, bar_type bar); 

// Etc. 

Answer 1

Il est en fait presque à la porte dans le cadre de la fonction Concepts et certains compilateurs mettent en œuvre déjà! Par exemple, avec GCC 4.9, si vous spécifiez -std=c++1y, vous pouvez réellement compiler et exécuter les éléments suivants:

auto print_arg(auto arg) { 
    std::cout << arg; 
}