polimorfismo
O polimorfismo é uma das características importantes da programação orientada a objetos. O significado literal pode ser entendido simplesmente como: múltiplas formas, múltiplas aparências. Na verdade, o significado essencial é o mesmo na programação orientada a objetos, significa que o mesmo método terá efeitos de execução diferentes quando executado por objetos diferentes.
Especificamente, a implementação do polimorfismo pode ser dividida em dois tipos: polimorfismo em tempo de compilação e polimorfismo em tempo de execução. O primeiro é o processo operacional específico determinado durante a compilação, e o último é o processo operacional determinado apenas durante a execução do programa. Esta determinação do processo de operação é vinculativa , também conhecida como vinculativa .
A ligação confirmada durante a compilação e a conexão é chamada de ligação estática . A sobrecarga de função e a instanciação de modelos de função que aprendemos anteriormente se enquadram nesta categoria. A outra é confirmar qual trecho de código é executado durante a execução, o que é chamado de ligação dinâmica . Nesse caso, não é possível confirmar qual trecho de código é executado durante a compilação, mas só pode ser confirmado após o programa ser executado. correr.
Comparando os dois, a ligação estática já determinou como executá-la durante a compilação, por isso é eficiente na execução enquanto a ligação dinâmica deve ser mais lenta, mas sua vantagem é a flexibilidade; Ambos têm seus próprios méritos e diferentes cenários de uso.
Abaixo, daremos um exemplo simples de vinculação estática:
/************************************//Des: demonstração do tutorial C++//Autor: Huang/ /Direitos autorais:www.dotcpp.com//Data:20/12/2017********************************* *** *******/#include<iostream>usingnamespacestd;#definePI3.1415926classPoint{private:intx,y;public:Point(intx=0,inty=0){this->x=x;this ->y =y;}doublearea(){return0.0;}};classCircle:publicPoint{private:intr;public:Circle(intx,inty,intR):Point(x,y){r=R;}doublearea (){ returnPI*r*r;}};intmain(){PointA(10,10);cout<<A.area()<<endl;CircleB(10,10,20);cout<<B.area ()< <endl;Point*p;p=&B;cout<<p->area()<<endl;Point&pp=B;cout<<pp.area()<<endl;return0;}Duas classes são definidas, uma classe de ponto e uma classe de círculo derivada. Você pode ver o código da função principal e os quatro resultados da área de saída.
Você pode comparar o código para entender as quatro saídas:
O primeiro cout gera a área de A, que é o método de área na classe Point. A área é 0, então não há problema.
O segundo cout produz a área de B, que é obviamente o método de área da classe derivada Circle. A área é calculada naturalmente de acordo com a fórmula e o valor é 1256,64, o que não é problema.
O terceiro cout gera o método area do objeto da classe Circle apontado pelo ponteiro do tipo Point p. Ele gera 0, que é obviamente o método area na classe Point. O que o C++ implementa aqui é a ligação estática, ou seja, ao compilar, ele determina qual área executar com base no tipo de p, portanto é 0.
O quarto tipo de cout funciona da mesma maneira. Ele atribui um objeto do tipo Circle a uma referência do tipo Point. C++ também executa ligação estática e também gera 0.
Obviamente, este não é o resultado que esperamos. Na verdade, para ponteiros e referências, preferimos executar os métodos dos objetos reais, em vez de determinar cegamente os tipos de ponteiros e referências.
Se você deseja atender aos nossos requisitos, não importa o tipo de ponteiro ou referência, ele deve ser decidido de forma flexível com base no objeto real apontado. Então precisamos alterar esse método de ligação estática padrão e usar ligação dinâmica, ou seja, decidida de forma flexível em tempo de execução.
Na próxima seção, as funções virtuais serão explicadas detalhadamente para todos!