foobar

@梦在天涯
这个有道理，有人验证过吗？

@爱上龙卷风
汗
不要感谢foobar，还是感谢google和c++编程思想吧。。。

@lovedday
多态是c++的一个特性 但是 c++远比这个复杂
你看看下面的代码，希望能明白我的意思

#include <iostream>
class Base
{
public:
virtual void foo() { std::cout << "Base::foo\n"; }
void foo(int) { std::cout << "Base::foo(int)\n"; }
};

class Derived : public Base
{
public:
void foo() { std::cout << "Derived::foo\n"; }
};

int main()
{
Base b;
b.foo(); // Base's foo() is called
b.foo(3); // Base's foo(int) is called
Derived d;
d.foo(); // Derived's foo() is called. The one in Base is hidden
d.foo(3); // error, that function is also hidden
Base &ref = d;
ref.foo(); // Derived's foo() is called. It overrides the Base version
ref.foo(3); // Base's foo(int) is called
}

@lovedday
上面说的不够确切
你c++学的好，知道多态这个概念，但是c++有很多缺点
楼主的那个例子，你在理解上是有误的
子类的确实用函数签名hide了父类的函数
所以你调用f的时候，肯定调用了f（double）

但是用dynamic type的时候，情况就不是这样了

nt main()
{
Base* pb = new Derived;
pb->f(10.5);

return 0;
}

输出当然是base
但是绝对不是子类有个函数输出base
而确实调用了父类的函数

@lovedday
pb是个父类指针，所以调用父类的f

Derived* pb = new Derived;
pb->f(10);

@lovedday
class Base
{
public:virtual void f(int x);
};
class Derived: public Base
{
public:virtual void f(double* pd);
};
int main()
{
Derived* pd = new Derived();
pd->f(10); //compile error!!!
}

这个例子只有声明没有定义，编译肯定有错
但是
在c++里，子类通过函数名字隐藏父类函数，而不是通过函数签名！

这个分析应该没什么问题
子类确实通过函数名字隐藏了父类的函数

@Mickey Mouse
应该不是const int吧
10 20 30 都是临时变量

@Mickey Mouse
vector 中存放const没有意义？
vector中没有const变量吧

@Mickey Mouse
我是感觉msdn在stl方面不如其他文档好

看stl的话，就是到cppreference也比到msdn好吧