暂时，让我们把标准库看作基本上是集合和算法的数据库。

如果您研究过数据库的历史，那么您无疑知道，在最初，数据库大多是“分层的”。分层数据库与经典的面向对象编程(OOP)非常相似——特别是单一继承类型，例如Smalltalk所使用的那种。

随着时间的推移，分层数据库显然可以用于建模几乎任何东西，但在某些情况下，单继承模型相当有限。如果你有一扇木门，你就可以很方便地把它看作一扇门，或者看作一块原材料(钢铁、木材等)。

因此，他们发明了网络模型数据库。网络模型数据库非常接近于多重继承。c++完全支持多重继承，而Java只支持有限的形式(只能继承一个类，但也可以实现任意多的接口)。

层次模型和网络模型数据库都已经从通用用途中消失了(尽管有一些仍然在相当特定的利基领域)。在大多数情况下，它们已经被关系数据库所取代。

关系数据库取代它的主要原因是它的多功能性。关系模型在功能上是网络模型的超集(网络模型又是层次模型的超集)。

c++在很大程度上遵循了同样的路径。单继承与层次模型、多继承与网络模型的对应关系较为明显。c++模板和层次模型之间的对应关系可能不太明显，但无论如何都非常接近。

我还没有看到它的正式证明，但我相信模板的功能是多重继承所提供的功能的超集(这显然是单一惯性的超集)。一个棘手的部分是模板大多是静态绑定的——也就是说，所有绑定都发生在编译时，而不是运行时。因此，正式证明继承提供了继承功能的超集可能有些困难和复杂(甚至可能是不可能的)。

在任何情况下，我认为这是c++不为它的容器使用继承的主要真正原因——没有真正的理由这样做，因为继承只提供模板所提供的功能的一个子集。由于模板在某些情况下基本上是必需的，因此它们几乎可以在任何地方使用。

对于我认为你在问或抱怨的问题，最直接的回答是:假设c++是一种面向对象语言是一个错误的假设。

c++是一种多范式语言。它可以使用面向对象原则编程，可以程序化编程，也可以泛型编程(模板)，使用c++ 11(以前称为c++ 0x)甚至可以对某些东西进行函数式编程。

c++的设计者认为这是一种优势，所以他们会争辩说，当泛型编程能更好地解决问题，并且更通用地解决问题时，限制c++像纯粹的面向对象语言一样运行将是一种倒退。

模板类型应该紧随其后 一个“概念”(输入迭代器，前进 迭代器，等等… 定义了概念的细节 完全由实现的 模板函数/类，而不是由 类所使用的类型的类 模板，这是一个 反对使用面向对象编程。

我认为您误解了模板对概念的预期用途。例如，前向迭代器是一个定义非常明确的概念。要找到使类成为前向迭代器必须有效的表达式，以及它们的语义(包括计算复杂性)，可以查看标准或http://www.sgi.com/tech/stl/ForwardIterator.html(必须按照Input、Output和Trivial Iterator的链接查看所有内容)。

该文档是一个非常好的界面，“概念的实际细节”就定义在那里。它们不是由前向迭代器的实现定义的，也不是由使用前向迭代器的算法定义的。

STL和Java处理接口的方式有三个不同之处:

1) STL使用对象定义了有效的表达式，而Java定义了必须在对象上调用的方法。当然，有效表达式可能是一个方法(成员函数)调用，但这并不一定是必须的。

2) Java接口是运行时对象，而STL概念在运行时是不可见的，即使使用RTTI。

3)如果你不能使STL概念所需的有效表达式有效，当你实例化一些模板时，你会得到一个未指定的编译错误。如果您未能实现Java接口的必要方法，则会得到一个特定的编译错误。

第三部分是如果你喜欢某种(编译时)"duck typing":接口可以是隐式的。在Java中，接口是显式的:当且仅当一个类说它实现了Iterable时，它才是Iterable。编译器可以检查它的方法的签名是否都存在并且正确，但是语义仍然是隐式的(即它们要么被记录下来，要么没有，但只有更多的代码(单元测试)才能告诉你实现是否正确)。

In C++, like in Python, both semantics and syntax are implicit, although in C++ (and in Python if you get the strong-typing preprocessor) you do get some help from the compiler. If a programmer requires Java-like explicit declaration of interfaces by the implementing class, then the standard approach is to use type traits (and multiple inheritance can prevent this being too verbose). What's lacking, compared with Java, is a single template which I can instantiate with my type, and which will compile if and only if all the required expressions are valid for my type. This would tell me whether I've implemented all the required bits, "before I use it". That's a convenience, but it's not the core of OOP (and it still doesn't test semantics, and code to test semantics would naturally also test the validity of the expressions in question).

STL对你来说可能是OO，也可能不是，但它确实把接口和实现清晰地分开了。它确实缺乏Java在接口上进行反射的能力，并且它以不同的方式报告违反接口需求的情况。

你可以告诉函数。期望前向迭代器仅为 看它的定义，你需要看 实现或文档…

Personally I think that implicit types are a strength, when used appropriately. The algorithm says what it does with its template parameters, and the implementer makes sure those things work: it's exactly the common denominator of what "interfaces" should do. Furthermore with STL, you're unlikely to be using, say, std::copy based on finding its forward declaration in a header file. Programmers should be working out what a function takes based on its documentation, not just on the function signature. This is true in C++, Python, or Java. There are limitations on what can be achieved with typing in any language, and trying to use typing to do something it doesn't do (check semantics) would be an error.

That said, STL algorithms usually name their template parameters in a way which makes it clear what concept is required. However this is to provide useful extra information in the first line of the documentation, not to make forward declarations more informative. There are more things you need to know than can be encapsulated in the types of the parameters, so you have to read the docs. (For example in algorithms which take an input range and an output iterator, chances are the output iterator needs enough "space" for a certain number of outputs based on the size of the input range and maybe the values therein. Try strongly typing that.)

以下是Bjarne对显式声明接口的介绍:http://www.artima.com/cppsource/cpp0xP.html

In generics, an argument must be of a class derived from an interface (the C++ equivalent to interface is abstract class) specified in the definition of the generic. That means that all generic argument types must fit into a hierarchy. That imposes unnecessary constraints on designs requires unreasonable foresight on the part of developers. For example, if you write a generic and I define a class, people can't use my class as an argument to your generic unless I knew about the interface you specified and had derived my class from it. That's rigid.

从另一个角度来看，使用duck类型，您可以在不知道接口存在的情况下实现接口。或者有人可以故意编写一个接口，让你的类实现它，并咨询你的文档，看看他们不会要求任何你没有做过的事情。这是灵活的。

这个问题有很多很好的答案。还应该提到模板支持开放设计。在面向对象编程语言的当前状态下，在处理此类问题时必须使用访问者模式，而真正的OOP应该支持多个动态绑定。参见c++的开放多方法，P. Pirkelbauer等。非常有趣的阅读。

模板的另一个有趣之处在于，它们也可以用于运行时多态性。例如

template<class Value,class T>
Value euler_fwd(size_t N,double t_0,double t_end,Value y_0,const T& func)
    {
    auto dt=(t_end-t_0)/N;
    for(size_t k=0;k<N;++k)
        {y_0+=func(t_0 + k*dt,y_0)*dt;}
    return y_0;
    }

注意，如果Value是某种类型的向量(不是std::vector，应该称为std::dynamic_array以避免混淆)，则此函数也可以工作。

如果func很小，这个函数将从内联中获得很多。示例使用

auto result=euler_fwd(10000,0.0,1.0,1.0,[](double x,double y)
    {return y;});

在这种情况下，你应该知道确切的答案(2.718…)，但是很容易构造一个没有初等解的简单ODE(提示:在y中使用多项式)。

现在，您在func中有一个大表达式，并且在许多地方使用ODE求解器，因此您的可执行文件到处都受到模板实例化的污染。怎么办呢?首先要注意的是，常规函数指针可以工作。然后，您希望添加curry，以便编写接口和显式实例化

class OdeFunction
    {
    public:
        virtual double operator()(double t,double y) const=0;
    };

template
double euler_fwd(size_t N,double t_0,double t_end,double y_0,const OdeFunction& func);

但是上面的实例化只适用于double，为什么不把接口写成模板呢:

template<class Value=double>
class OdeFunction
    {
    public:
        virtual Value operator()(double t,const Value& y) const=0;
    };

并专门化一些常见的值类型:

template double euler_fwd(size_t N,double t_0,double t_end,double y_0,const OdeFunction<double>& func);

template vec4_t<double> euler_fwd(size_t N,double t_0,double t_end,vec4_t<double> y_0,const OdeFunction< vec4_t<double> >& func); // (Native AVX vector with four components)

template vec8_t<float> euler_fwd(size_t N,double t_0,double t_end,vec8_t<float> y_0,const OdeFunction< vec8_t<float> >& func); // (Native AVX vector with 8 components)

template Vector<double> euler_fwd(size_t N,double t_0,double t_end,Vector<double> y_0,const OdeFunction< Vector<double> >& func); // (A N-dimensional real vector, *not* `std::vector`, see above)

如果函数首先是围绕接口设计的，那么您将被迫继承ABC。现在您有了这个选项，还有函数指针、lambda或任何其他函数对象。这里的关键是我们必须有operator()()，我们必须能够在它的返回类型上使用一些算术运算符。因此，在这种情况下，如果c++没有操作符重载，模板机制就会中断。

The concept of separating interface from interface and being able to swap out the implementations is not intrinsic to Object-Oriented Programming. I believe it's an idea that was hatched in Component-Based Development like Microsoft COM. (See my answer on What is Component-Driven Development?) Growing up and learning C++, people were hyped out inheritance and polymorphism. It wasn't until 90s people started to say "Program to an 'interface', not an 'implementation'" and "Favor 'object composition' over 'class inheritance'." (both of which quoted from GoF by the way).

然后，Java出现了内置的垃圾收集器和接口关键字，突然之间，将接口和实现分开变得可行了。不知不觉，这个想法就成为了OO的一部分。c++、模板和STL的出现要早于这一切。

最基本的问题是

void MyFunc(ForwardIterator *I);

你如何安全地获取迭代器返回的东西的类型?对于模板，这是在编译时为您完成的。