如何会导致c++的多态失效

C++中的多态是通过继承和虚函数实现的。如果以下情况之一发生，可能会导致多态失效：

1.没有将基类析构函数声明为虚函数。如果使用基类指针或引用来删除派生类对象，则只会调用基类的析构函数，从而导致派生类中的资源泄漏。

2.使用了非虚函数来覆盖基类中的虚函数。如果在派生类中定义了与基类中虚函数具有相同名称和参数列表的非虚函数，则在使用基类指针或引用调用该函数时，将始终调用基类中的函数，而不是派生类中的函数。

3.在派生类中重载了基类的虚函数，但是函数签名不同。如果在派生类中重载了基类中的虚函数，但是函数签名不同，则在使用基类指针或引用调用该函数时，将始终调用基类中的函数，而不是派生类中的函数。

相关问题

c++ 多态

C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。

C++中的多态性有两种：静态多态和动态多态。

1. 静态多态

静态多态是指在编译时就已经确定了函数的调用，也称为编译时多态。C++中实现静态多态的方式主要有函数重载和运算符重载。

函数重载是指在同一作用域内定义多个同名函数，但它们的参数列表不同。编译器根据传递给函数的参数类型和数量来确定调用哪个函数。例如：

void print(int num) {
    std::cout << "This is an integer: " << num << std::endl;
}

void print(double num) {
    std::cout << "This is a double: " << num << std::endl;
}

int main() {
    int a = 10;
    double b = 3.14;

    print(a);   // 调用第一个print函数
    print(b);   // 调用第二个print函数
}

运算符重载是指对C++中的运算符进行重新定义，使其能够用于自定义的数据类型。例如：

class Complex {
public:
    Complex(double real, double imag) : m_real(real), m_imag(imag) {}
    Complex operator+(const Complex& other) const {
        return Complex(m_real + other.m_real, m_imag + other.m_imag);
    }
private:
    double m_real;
    double m_imag;
};

int main() {
    Complex a(1.0, 2.0);
    Complex b(3.0, 4.0);

    Complex c = a + b;  // 调用Complex类中重载的+运算符
}

2. 动态多态

动态多态是指在运行时根据对象的实际类型来确定调用哪个函数，也称为运行时多态。C++中实现动态多态的方式主要有虚函数和纯虚函数。

虚函数是在父类中定义的可以被子类重写的函数，使用virtual关键字声明。当一个对象的指针或引用指向一个子类对象时，调用虚函数时会根据实际的对象类型来确定调用哪个函数。例如：

class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape." << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

int main() {
    Shape* shape_ptr = new Circle();
    shape_ptr->draw();  // 调用Circle类中重写的draw函数
}

纯虚函数是在父类中定义的没有实现的虚函数，使用纯虚函数声明（如virtual void func() = 0;）。父类中包含纯虚函数的类称为抽象类，抽象类不能被实例化，只能作为基类来派生子类。子类必须实现父类的纯虚函数才能实例化。例如：

class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

int main() {
    Shape* shape_ptr = new Circle();
    shape_ptr->draw();  // 调用Circle类中重写的draw函数
}

C++ 多态

C++中的多态是指在基类和派生类之间，通过虚函数实现的动态绑定机制。通过多态性，可以在基类的指针或引用上调用派生类的函数，实现动态绑定和运行时多态。

在C++中，要实现多态性，需要使用以下两个关键字：

1. virtual：在基类中声明虚函数，表示该函数可以被派生类重写。

2. override：在派生类中重写虚函数时，使用override关键字，表示该函数是对基类虚函数的覆盖。

下面是一个简单的示例：

#include <iostream>
using namespace std;

class Shape {
   protected:
      int width;
      int height;
   public:
      virtual int area() {
         cout << "Parent class area :" << endl;
         return 0;
      }
};

class Rectangle: public Shape {
   public:
      int area () override {
         cout << "Rectangle class area :" << endl;
         return (width * height);
      }
};

class Triangle: public Shape {
   public:
      int area () override {
         cout << "Triangle class area :" << endl;
         return (width * height / 2);
      }
};

int main() {
   Shape *shape;
   Rectangle rec;
   Triangle  tri;

   // 矩形对象的地址赋值给指向基类的指针
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();

   // 三角形对象的地址赋值给指向基类的指针
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();

   return 0;
}

在上面的示例中，定义了一个Shape基类和两个派生类Rectangle和Triangle。在Shape类中声明了一个虚函数area()，在Rectangle和Triangle类中重写了该函数。在main函数中，分别创建了Rectangle和Triangle对象，并将它们的地址赋值给基类Shape的指针shape。通过shape指针调用area()函数时，会根据对象的实际类型，动态地调用相应的派生类函数，实现了多态性和动态绑定机制。

总的来说，C++中的多态性是一种重要的面向对象特性，可以提高程序的可扩展性和可维护性，应用广泛。在实际的开发中，多态性通常与其他面向对象的技术和设计模式相结合，从而实现更加复杂的功能和需求。