Eu tenho lido sobre funções virtuais e descobri,

VF são usados ​​no polimorfismo de uma classe herdada.

Portanto, se uma classe e uma classe derivada tiverem o mesmo nome de função, a VF ligará a função apropriada à chamada de função.

Ou seja, se a função em questão é designada virtual na classe base, a função da classe derivada seria chamada. Se não for virtual, a função da classe base será chamada.

Por padrão, em Java: todas as funções são virtuais C ++: não virtuais e podem ser feitas virtuais em Java usando o modificador de acesso privado final, enquanto em C ++ usando a palavra-chave virtual para tornar uma função virtual.

Com base na teoria acima, escrevi o código:

#include <iostream>

class base{
    public : 
        virtual void function1(){
            std::cout<<"BaseVirtual"<<std::endl;
        }

        void function2(){
            std::cout<<"Base NonVirtual"<<std::endl;
        }
};


class derieved: public base
{
    public : 
        void function1(){
            std::cout<<"Derieved Virtual"<<std::endl;
        }

        void function2(){
            std::cout<<"Derieved NonVirtual"<<std::endl;
        }
};



int main()
{
    base b1;
    derieved d1;

    b1.function1();
    b1.function2();

    d1.function1();
    d1.function2();    

}

Agora, com base no fato, se sua função virtual é chamada de função de classe derivada, minha saída para o programa acima deve ser:

BaseVirtual
Base NonVirtual
Derieved Virtual
Base NonVirtual

no entanto, acabou por ser:

BaseVirtual
Base NonVirtual
Derieved Virtual
Derieved NonVirtual

que deve estar certo, claro. Então, minha pergunta é a saída viola totalmente a afirmaçãoSe a função em questão é designada virtual na classe base, a função da classe derivada seria chamada. Se não for virtual, a função da classe base será chamada. para a chamada:

  d1.function2();