C++ '；类main类'；没有名为'的成员；普罗森特 #包括 #包括 使用名称空间std； 类主类{ 公众： 虚拟void getData（）=0； 虚拟void printData（）=0； }; 等级车：公共级{ 私人： int-hp； int电机； 公众： 汽车（内部马力=0，内部电机=0）{ hp=_hp； 马达=_马达； } ~Car（）{ cout_hp； hp=_hp； cout>\u电机； 马达=_马达； } void printData（）{ cout

发生错误是因为您试图访问MainClass对象中的

procent（）

方法。要解决此问题，您需要将其作为虚拟方法添加到MainClass中，并在Car对象中重写它

另外，请确保删除分配的内存

#包括
#包括
使用名称空间std；
类主类{
公众：
虚拟void getData（）=0；
虚拟void printData（）=0；
虚拟void procent（）=0；
};
等级车：公共级{
私人：
int-hp；
int电机；
公众：
汽车（内部马力=0，内部电机=0）{
hp=_hp；
马达=_马达；
}
~Car（）{
cout_hp；
hp=_hp；
cout>\u电机；
马达=_马达；
}
void printData（）覆盖{
cout发生错误是因为您试图访问MainClass对象中的
procent（）
方法。要解决此问题，您需要将其作为虚拟方法添加到MainClass中，并在Car对象中重写它

另外，请确保删除分配的内存

#包括
#包括
使用名称空间std；
类主类{
公众：
虚拟void getData（）=0；
虚拟void printData（）=0；
虚拟void procent（）=0；
};
等级车：公共级{
私人：
int-hp；
int电机；
公众：
汽车（内部马力=0，内部电机=0）{
hp=_hp；
马达=_马达；
}
~Car（）{
cout_hp；
hp=_hp；
cout>\u电机；
马达=_马达；
}
void printData（）覆盖{
cout
procent（）
不是
类MainClass
的成员

p
的指针类型是
MainClass

因此，您只能访问
MainClass
中已知的内容。
指针
p
实际上包含
Car
实例的地址，这不算在内

getData（）
和
printData（）
是已知的，但
procent（）
不是。（它是派生的
类Car的一部分
）

您可以通过
MainClass
指针
p
访问
Car
s被
getData（）
和
printData（）
覆盖的
s是（奇妙的）多形性的结果，即它们是
virtual

因此，这是一个潜在的解决方案–使
procent（）
成为
MainClass
的
virtual
成员函数


还有另一种解决方案，但只能作为最后手段：

您可以使用检查
p
是否实际包含指向
类Car的实例的指针：

#include <iostream>
#include <vector>
using namespace std;
class MainClass{
    public:
        virtual void getData() = 0;
        virtual void printData() = 0;
};
class Car : public MainClass{
    private:
        int hp;
        int motor;
    public:
        Car(int _hp = 0, int _motor = 0){
            hp = _hp;
            motor = _motor;
        }
        ~Car(){
            cout << "The program is over";
        }
        void getData(){
            cout << "HorsePower = ";
            int _hp;
            cin >> _hp;
            hp = _hp;
            cout << "Motor = ";
            int _motor;
            cin >> _motor;
            motor = _motor;
        }
        void printData(){
            cout << "HorsePower = " << hp << '\n';
            cout << "Motor = " << motor << '\n';
        }
        float procent(){
            return float(motor) / hp;
        }
};
int main()
{
    MainClass *p = new Car;
    p -> getData();
    p -> printData();
    cout << p -> procent();
    return 0;
}


带有
dynamic\u cast
的解决方案可能更适合于大型类继承树，因为在基类中添加
virtual
成员函数对于派生类的任何（外来）特定功能都是不切实际的。
procent（）
不是
类MainClass
的成员

p
的指针类型是
MainClass

因此，您只能访问
MainClass
中已知的内容。
指针
p
实际上包含
Car
实例的地址，这不算在内

getData（）
和
printData（）
是已知的，但
procent（）
不是。（它是派生的
类Car的一部分
）

您可以通过
MainClass
指针
p
访问
Car
s被
getData（）
和
printData（）
覆盖的
s是（奇妙的）多形性的结果，即它们是
virtual

因此，这是一个潜在的解决方案–使
procent（）
成为
MainClass
的
virtual
成员函数


还有另一种解决方案，但只能作为最后手段：

您可以使用检查
p
是否实际包含指向
类Car的实例的指针：

#include <iostream>
#include <vector>
using namespace std;
class MainClass{
    public:
        virtual void getData() = 0;
        virtual void printData() = 0;
};
class Car : public MainClass{
    private:
        int hp;
        int motor;
    public:
        Car(int _hp = 0, int _motor = 0){
            hp = _hp;
            motor = _motor;
        }
        ~Car(){
            cout << "The program is over";
        }
        void getData(){
            cout << "HorsePower = ";
            int _hp;
            cin >> _hp;
            hp = _hp;
            cout << "Motor = ";
            int _motor;
            cin >> _motor;
            motor = _motor;
        }
        void printData(){
            cout << "HorsePower = " << hp << '\n';
            cout << "Motor = " << motor << '\n';
        }
        float procent(){
            return float(motor) / hp;
        }
};
int main()
{
    MainClass *p = new Car;
    p -> getData();
    p -> printData();
    cout << p -> procent();
    return 0;
}


对于大型类继承树来说，
dynamic\u cast
的解决方案可能更可取，因为在这些树中，为任何（外来的）类向基类添加
virtual
成员函数是不切实际的派生类的特定功能。
您说您不想将procent添加到从MainClass派生的每个类中，但是当p指向其中一个类并调用procent时，您希望发生什么？了解在这种情况下您希望发生什么应该有助于您找到正确的解决方案。您说您愿意不想将procent添加到从MainClass派生的每个类中，但是当p指向其中一个类并调用procent时，您希望发生什么？了解在这种情况下您希望发生什么应该有助于指导您找到正确的解决方案。