多态性和函数重载？

我有一个Base类和Derived类Base多态性和函数重载？

struct Base{}; 
struct Derived: public Base{};

我想要接受Base*功能，但通过了Derived*时具有不同的功能。

void myFunc(Base* base){ 
std::cout << "myFunc(base)" << std::endl; 
} 

void myFunc(Derived* derived){ 
std::cout << "myFunc(derived)" << std::endl; 
}

我的问题是，当我尝试使用多态，根据需要，因为我总是传递Base*的功能不行为。

Base* base = new Base(); 
Base* derived = new Derived(); 

myFunc(base); 
myFunc(derived);

输出：

myFunc(base) 
myFunc(base)

希望的输出：

myFunc(base) 
myFunc(derived)

我不能使用铸造等的原因 - (Derived*)derived - 是因为我使用的Base*

阵列

#include <iostream> 

struct Base{};  
struct Derived: public Base{}; 

void myFunc(Base* base){ 
std::cout << "myFunc(base)" << std::endl; 
} 

void myFunc(Derived* derived){ 
std::cout << "myFunc(derived)" << std::endl; 
} 

void myFunc(Base** bases, size_t count){ 
for(auto i = 0; i < count; i++){ 
    myFunc(bases[i]); 
} 
} 

int main(){ 
Base* bases[2]; 
bases[0] = new Base(); 
bases[1] = new Derived(); 

myFunc(bases, 2); 
}

我不能让myFunc成为虚拟成员函数的原因是因为我想将myFunc的功能封装在单独的类中以避免单一的基类。

#include <iostream> 

struct Base{}; 

struct Derived: public Base{}; 

struct DoesStuff{ 
void doStuff(Base* base){ 
    std::cout << "doStuff(base)" << std::endl; 
} 

void doStuff(Derived* derived){ 
    std::cout << "doStuff(derived)" << std::endl; 
} 

void doStuff(Base** bases, size_t count){ 
    for(auto i = 0; i < count; i++){ 
    doStuff(bases[i]); 
    } 
} 
}; 

struct DoesOtherStuff{ 
void doOtherStuff(Base* base){ 
    std::cout << "doOtherStuff(base)" << std::endl; 
} 

void doOtherStuff(Derived* derived){ 
    std::cout << "doOtherStuff(derived)" << std::endl; 
} 

void doOtherStuff(Base** bases, size_t count){ 
    for(auto i = 0; i < count; i++){ 
    doOtherStuff(bases[i]); 
    } 
} 
}; 

int main(){ 
Base* bases[2]; 
bases[0] = new Base(); 
bases[1] = new Derived(); 

DoesStuff stuffDoer; 
DoesOtherStuff otherStuffDoer; 

stuffDoer.doStuff(bases, 2); 
otherStuffDoer.doOtherStuff(bases, 2); 
}

如何获得myFunc知道Base*是偷偷Derived*。我想我可以使用typeid，但我不确定这是最合适的解决方案。如我错了请纠正我。

来源

2015-11-09 Willy Goat

你必须声明你的函数是虚拟的。请记住，最好通过引用而不是指针 – KostasRim

尝试使用模板并提供适当的特化，而不是通过'Base *'和'Derived *'指针类型引入歧义。 –

@ KostasRim有问题的功能没有周边类。这些应该如何“虚拟”呢？ –

为了得到这个通过多态性的工作是做到以下几点：

创建的基类，你想要做的基类做一个虚拟成员功能。
重写Derived类中的该成员函数，并让它为Derived类执行所需操作。

这就是多态性的本质。它不适用于非成员函数或免费函数的原因是因为它们都传递了基类指针。

来源

2015-11-09 22:56:14

让我们来添加它只是_runtime_的本质（又名_dynamic_）多态性。重载或模板路由也是多态的，但不是经典的OOP多态（我认为经典的OOP风格在C++中应该是罕见的，因为通常其他语言更适合这种...） – sehe

这很公平。但我不同意括号内的陈述的最后部分。 –

如果'myFunc'是一个类的一部分，我有责任为'Base'和'Derived'做些什么。现在我正在避免一个在'Base'里面有几十个不相关的函数的问题，而不是在'Base'的数组上运行的类＃ –

多态性和函数重载？

回答

相关问题