C + + 中的多态性

在 C + + 中，重要的区别是运行时绑定和编译时绑定。

|----------------------+--------------|
| Form                 | Resolved at  |
|----------------------+--------------|
| function overloading | compile-time |
| operator overloading | compile-time |
| templates            | compile-time |
| virtual methods      | run-time     |
|----------------------+--------------|

注意，运行时多态性仍然可以在编译时解决，但这只是优化。需要有效地支持运行时解决方案，并与其他问题进行权衡，这是导致虚函数成为现实的部分原因。这是 C + + 中所有形式的多态性的关键——每种多态性都源于在不同上下文中进行的不同权衡。

函数重载和运算符重载在各个方面都是一样的。名称和使用它们的语法不影响多态性。

模板允许您一次指定大量的函数重载。

对于同样的解析时间概念，还有另一组名称..。

|---------------+--------------|
| early binding | compile-time |
| late binding  | run-time     |
|---------------+--------------|

这些名称更多地与 OOP 相关联，因此说模板或其他非成员函数使用早期绑定有点奇怪。

为了更好地理解虚拟函数和函数重载之间的关系，理解“单一派遣”和“多分派”之间的区别也很有用。这个想法可以被理解为一种进步。

• 首先，存在单纯函数。函数的实现由函数名唯一标识。没有一个参数是特殊的。
• 然后，有一个单一的派遣。其中一个参数被认为是特殊的，并用于(连同名称)标识要使用的实现。在 OOP 中，我们倾向于把这个参数看作“对象”，在函数名之前列出它，等等。
• 还有多分派。任何/所有参数都有助于确定要使用的实现。因此，再次强调，没有任何参数需要是特殊的。

很明显，OOP 不仅仅是一个将一个参数指定为特殊参数的借口，但这只是其中的一部分。回到我所说的权衡——单一分派非常容易有效地完成(通常的实现被称为“虚拟表”)。多分派更为笨拙，不仅在效率方面，而且在单独编译方面也是如此。如果你好奇，你可以查查“表达问题”。

正如对非成员函数使用术语“早期绑定”有点奇怪一样，在编译时解析多态性的地方使用术语“单一分派”和“多分派”也有点奇怪。通常，c + + 被认为没有多分派，这被认为是一种特殊的运行时解析。然而，函数重载可以看作是在编译时完成的多分派。

回到参数多态和特别多态的话题，这些术语在函数式编程中更为流行，而且它们在 C + + 中并不能很好地工作。即便如此。

参数多态意味着你使用类型作为参数，不管你使用什么类型作为参数，都使用完全相同的代码。

Ad-hoc 多态性是 Ad-hoc 的意思是，您根据特定类型提供不同的代码。

重载和虚函数都是 ad-hoc 多态性的例子。

同样，这里有一些同义词..。

|------------+---------------|
| parametric | unconstrained |
| ad-hoc     | constrained   |
|------------+---------------|

除了这些并不是完全同义词，尽管它们通常被当作同义词来对待，这就是在 C + + 中容易产生混淆的地方。

将它们视为同义词背后的原因是，通过将多态性限制为特定类型，就可以使用特定于这些类型的操作。这里的“类”一词可以在 OOP 意义上进行解释，但实际上只是指共享某些操作的类型集(通常命名为)。

因此，参数多态通常(至少在默认情况下)暗示无约束的多态性。因为不管类型参数是什么，都使用相同的代码，所以只有那些适用于所有类型的操作才受支持。通过不限制类型集，可以严格限制可以应用于这些类型的操作集。

例如 Haskell，你可以有..。

myfunc1 :: Bool -> a -> a -> a
myfunc1 c x y = if c then x else y

这里的 a是一个无约束的多态类型。它可以是任何类型，所以对于这种类型的值，我们没有什么可以做的。

myfunc2 :: Num a => a -> a
myfunc2 x = x + 3

在这里，a被约束为作用类似于数字的 Num类类型的成员。该约束允许您对这些值进行数字化处理，例如添加它们。甚至 3是多态类型推断，你指的是 a类型的 3。

我认为这是受约束的参数多态。只有一个实现，但它只能应用于受限情况。Ad-hoc 方面是选择使用哪个 +和 3。Num的每个“实例”都有自己独特的实现。因此，即使在哈斯克尔，“参数化”和“无约束”也不是真正的同义词——不要怪我，这不是我的错！

在 C + + 中，重载和虚函数都是 ad-hoc 多态性。Ad-hoc 多态性的定义并不关心是在运行时还是在编译时选择实现。

如果每个模板参数的类型都是 typename，那么 c + + 就非常接近模板的参数多态了。有类型参数，并且不管使用哪种类型，都有一个单一的实现。但是，“替换失败不是错误”规则意味着隐式约束是在模板中使用操作的结果。其他复杂性包括模板专门化，用于提供替代模板——不同的(特别的)实现。

所以在某种程度上，c + + 有自己的参数多态，但是它受到隐式约束，并且可以被特定的替代方案所覆盖——即这种分类方法并不适用于 c + + 。

下面是一个使用多态类的基本示例

#include <iostream>


class Animal{
public:
Animal(const char* Name) : name_(Name){/* Add any method you would like to perform here*/
virtual void Speak(){
std::cout << "I am an animal called " << name_ << std::endl;
}
const char* name_;
};


class Dog : public Animal{
public:
Dog(const char* Name) : Animal(Name) {/*...*/}
void Speak(){
std::cout << "I am a dog called " << name_ << std::endl;
}
};


int main(void){
Animal Bob("Bob");
Dog Steve("Steve");
Bob.Speak();
Steve.Speak();
//return (0);
}

这可能没有任何帮助，但我这样做是为了向我的朋友介绍编程，给出定义函数，如 START和 END的主要功能，所以它不是太令人畏惧(他们只使用 Main.cpp文件)。它包含多态类和结构、模板、向量、数组、预处理器指令、友谊、操作符和指针(在尝试多态性之前，你可能应该知道所有这些) :

注意: 它还没有完成，但你可以得到的想法

Main.cpp

#include "main.h"
#define ON_ERROR_CLEAR_SCREEN false
START
Library MyLibrary;
Book MyBook("My Book", "Me");
MyBook.Summarize();
MyBook += "Hello World";
MyBook += "HI";
MyBook.EditAuthor("Joe");
MyBook.EditName("Hello Book");
MyBook.Summarize();
FixedBookCollection<FairyTale> FBooks("Fairytale Books");
FairyTale MyTale("Tale", "Joe");
FBooks += MyTale;
BookCollection E("E");
MyLibrary += E;
MyLibrary += FBooks;
MyLibrary.Summarize();
MyLibrary -= FBooks;
MyLibrary.Summarize();
FixedSizeBookCollection<5> Collection("My Fixed Size Collection");
/* Extension Work */ Book* Duplicate = MyLibrary.DuplicateBook(&MyBook);
/* Extension Work */ Duplicate->Summarize();
END

主

#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <type_traits>
#include <array>
#ifndef __cplusplus
#error Not C++
#endif
#define START int main(void)try{
#define END GET_ENTER_EXIT return(0);}catch(const std::exception& e){if(ON_ERROR_CLEAR_SCREEN){system("cls");}std::cerr << "Error: " << e.what() << std::endl; GET_ENTER_EXIT return (1);}
#define GET_ENTER_EXIT std::cout << "Press enter to exit" << std::endl; getchar();
class Book;
class Library;
typedef std::vector<const Book*> Books;
bool sContains(const std::string s, const char c){
return (s.find(c) != std::string::npos);
}
bool approve(std::string s){
return (!sContains(s, '#') && !sContains(s, '%') && !sContains(s, '~'));
}
template <class C> bool isBook(){
return (typeid(C) == typeid(Book) || std::is_base_of<Book, C>());
}
template<class ClassToDuplicate> class DuplicatableClass{
public:
ClassToDuplicate* Duplicate(ClassToDuplicate ToDuplicate){
return new ClassToDuplicate(ToDuplicate);
}
};
class Book : private DuplicatableClass<Book>{
friend class Library;
friend struct BookCollection;
public:
Book(const char* Name, const char* Author) : name_(Name), author_(Author){}
void operator+=(const char* Page){
pages_.push_back(Page);
}
void EditAuthor(const char* AuthorName){
if(approve(AuthorName)){
author_ = AuthorName;
}
else{
std::ostringstream errorMessage;
errorMessage << "The author of the book " << name_ << " could not be changed as it was not approved";
throw std::exception(errorMessage.str().c_str());
}
}
void EditName(const char* Name){
if(approve(Name)){
name_ = Name;
}
else{
std::ostringstream errorMessage;
errorMessage << "The name of the book " << name_ << " could not be changed as it was not approved";
throw std::exception(errorMessage.str().c_str());
}
}
virtual void Summarize(){
std::cout << "Book called " << name_ << "; written by " << author_ << ". Contains "
<< pages_.size() << ((pages_.size() == 1) ? " page:" : ((pages_.size() > 0) ? " pages:" : " pages")) << std::endl;
if(pages_.size() > 0){
ListPages(std::cout);
}
}
private:
std::vector<const char*> pages_;
const char* name_;
const char* author_;
void ListPages(std::ostream& output){
for(int i = 0; i < pages_.size(); ++i){
output << pages_[i] << std::endl;
}
}
};
class FairyTale : public Book{
public:
FairyTale(const char* Name, const char* Author) : Book(Name, Author){}
};
struct BookCollection{
friend class Library;
BookCollection(const char* Name) : name_(Name){}
virtual void operator+=(const Book& Book)try{
Collection.push_back(&Book);
}catch(const std::exception& e){
std::ostringstream errorMessage;
errorMessage << e.what() << " - on line (approx.) " << (__LINE__ -3);
throw std::exception(errorMessage.str().c_str());
}
virtual void operator-=(const Book& Book){
for(int i = 0; i < Collection.size(); ++i){
if(Collection[i] == &Book){
Collection.erase(Collection.begin() + i);
return;
}
}
std::ostringstream errorMessage;
errorMessage << "The Book " << Book.name_ << " was not found, and therefore cannot be erased";
throw std::exception(errorMessage.str().c_str());
}
private:
const char* name_;
Books Collection;
};
template<class FixedType> struct FixedBookCollection : public BookCollection{
FixedBookCollection(const char* Name) : BookCollection(Name){
if(!isBook<FixedType>()){
std::ostringstream errorMessage;
errorMessage << "The type " << typeid(FixedType).name() << " cannot be initialized as a FixedBookCollection";
throw std::exception(errorMessage.str().c_str());
delete this;
}
}
void operator+=(const FixedType& Book)try{
Collection.push_back(&Book);
}catch(const std::exception& e){
std::ostringstream errorMessage;
errorMessage << e.what() << " - on line (approx.) " << (__LINE__ -3);
throw std::exception(errorMessage.str().c_str());
}
void operator-=(const FixedType& Book){
for(int i = 0; i < Collection.size(); ++i){
if(Collection[i] == &Book){
Collection.erase(Collection.begin() + i);
return;
}
}
std::ostringstream errorMessage;
errorMessage << "The Book " << Book.name_ << " was not found, and therefore cannot be erased";
throw std::exception(errorMessage.str().c_str());
}
private:
std::vector<const FixedType*> Collection;
};
template<size_t Size> struct FixedSizeBookCollection : private std::array<const Book*, Size>{
FixedSizeBookCollection(const char* Name) : name_(Name){ if(Size < 1){ throw std::exception("A fixed size book collection cannot be smaller than 1"); currentPos = 0; } }
void operator+=(const Book& Book)try{
if(currentPos + 1 > Size){
std::ostringstream errorMessage;
errorMessage << "The FixedSizeBookCollection " << name_ << "'s size capacity has been overfilled";
throw std::exception(errorMessage.str().c_str());
}
this->at(currentPos++) = &Book;
}catch(const std::exception& e){
std::ostringstream errorMessage;
errorMessage << e.what() << " - on line (approx.) " << (__LINE__ -3);
throw std::exception(errorMessage.str().c_str());
}
private:
const char* name_;
int currentPos;
};
class Library : private std::vector<const BookCollection*>{
public:
void operator+=(const BookCollection& Collection){
for(int i = 0; i < size(); ++i){
if((*this)[i] == &Collection){
std::ostringstream errorMessage;
errorMessage << "The BookCollection " << Collection.name_ << " was already in the library, and therefore cannot be added";
throw std::exception(errorMessage.str().c_str());
}
}
push_back(&Collection);
}
void operator-=(const BookCollection& Collection){
for(int i = 0; i < size(); ++i){
if((*this)[i] == &Collection){
erase(begin() + i);
return;
}
}
std::ostringstream errorMessage;
errorMessage << "The BookCollection " << Collection.name_ << " was not found, and therefore cannot be erased";
throw std::exception(errorMessage.str().c_str());
}
Book* DuplicateBook(Book* Book)const{
return (Book->Duplicate(*Book));
}
void Summarize(){
std::cout << "Library, containing " << size() << ((size() == 1) ? " book collection:" : ((size() > 0) ? " book collections:" : " book collections")) << std::endl;
if(size() > 0){
for(int i = 0; i < size(); ++i){
std::cout << (*this)[i]->name_ << std::endl;
}
}
}
};

如果有人对这些人说卡

The Surgeon
The Hair Stylist
The Actor

会发生什么？

The Surgeon would begin to make an incision.
The Hair Stylist would begin to cut someone's hair.
The Actor would abruptly stop acting out of the current scene, awaiting directorial guidance.

因此上面的表示显示了 OOP 中的多态性(相同的名称，不同的行为)是什么。

如果你要去参加一个面试，面试官要求你在我们坐着的同一个房间里展示一个多态性的实例，比如说

应答-门/窗

想知道怎么做？

通过门/窗——人可以进来，空气可以进来，光可以进来，雨可以进来，等等。

一种形式的不同行为(多态性)。

为了更好地理解它，我用了上面的例子。.如果代码需要参考，请遵循以上答案。

多态性意味着操作符可以在不同的实例下以不同的方式进行操作。多态性用于实现继承。对于 ex，我们已经为一个类形状定义了一个 fn 绘制() ，然后绘制 fn 可以实现为绘制圆形，盒子，三角形和其他形状。(这是类形状的对象)