相关疑难解决方法(0)

据我所知,override在C++ 11中引入关键字只不过是一个检查,以确保正在实现override的virtual函数是基类中的函数.

是吗？

据我所知,override关键字声明给定的声明实现了一个基本virtual方法,如果找不到匹配的基本方法,编译应该失败.

我对该final关键字的理解是它告诉编译器没有类会覆盖这个virtual函数.

那是override final多余的吗？好像编译好了.哪些信息override final传达的final不是？这种组合的用例是什么？

我理解C++覆盖的目的,但是与其他更高级别的语言相比,它的实现有点困惑,默认情况下需要使用它.

在C++ 11的wiki页面将其描述为一个"技术上标识符声明符属性",但没有详细说明,为什么它不是单纯的语言关键字.

尝试将多态性作为初学者.我想我正在尝试使用不同语言的相同代码,但结果并不相同:

C++

#include <iostream>
using namespace std;

class A {
    public:

    void whereami() {
        cout << "You're in A" << endl;
    }
};

class B : public A {
    public:

    void whereami() {
        cout << "You're in B" << endl;
    }
};

int main(int argc, char** argv) {
    A a;
    B b;
    a.whereami();
    b.whereami();
    A* c = new B();
    c->whereami();
    return 0;
}

结果:

You're in A
You're in B
You're in A

Java:

public class B extends A{

    void …

问题是我正在努力制作类Shape 的对象。我声明了向量，但不知道如何将它连接到类Shape及其对象。代码本身有一个基类，它是Shape，然后是两个子类Circle和Rectancle。代码的思路是在main函数中使用一个vector，对于Circle区域和Rectangle区域有多种情况。这是代码：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Shape
{
public:
    virtual double GetArea() const = 0
    {

    }

private:

};

class Circle : public Shape
{
public:
    Circle(double p, double r) // constructor
    {
        pi = p;
        radius = r;
    }

    Circle() : pi(3.14), radius(0) {} // default constructor

    void SetRadius(double value)
    {
        radius = value;
    }

    double GetRadius() const
    { …

在我的程序的主文件中，我有以下声明

int main()
{
    Customer c;
    Part p;
    Builder b;
    auto partsVec =  readpartFile();
    auto customerVec = readcustomerFile();
    auto builderVec = readbuilderFile();

    fexists("Parts.txt");
    complexity(c, partsVec);
    robotComplexity(partsVec,customerVec);
    writeFile(buildAttempt(b, complexity(c, partsVec), variability(customerVec, builderVec)));
}

我的头文件由以下内容组成

vector<Part> readpartFile();

vector<Customer> readcustomerFile();

vector<Builder> readbuilderFile();

float complexity(const Customer& c, const std::vector<Part>& parts);

void robotComplexity(vector<Part> vecB, vector<Customer> vecC);

double variability(const vector<Customer>& customerList, const vector<Builder>& builderList);

vector<double> buildAttempt(Builder b, double variaiblity, double complexityRobot);

void writeFile(vector<double> build);

除了 robotsComplexity 之外，所有功能都链接在一起。我在 main 中声明此函数会产生以下错误。

重载函数“robotComplexity”的多个实例与参数列表匹配： -- function "robotComplexity(const std::vector> &parts, const …

不确定我的继承在这里出了问题，但我似乎只能在将子类实例存储在基类指针中时才能访问基类的方法：

class Car
{
    public:
        Car():type("Car") {};
        Car(const char* t):type(t) {};
        void get_type() const { return this->type; };
    private:
        std::string type;
};

class Ford : public Car
{
    public:
        Ford():Car("Ford"), doors(4) {};
        Ford(int x):Car("Ford"), doors(x) {};
        void get_doors() const { return this->doors; };
    private:
        int doors;
};

int main()
{
    Car* c = nullptr;
    c = new Ford();
    c->get_doors(); // doesn't exist, only allows for get_type()
}

这很可能是指针的误用。我承认 C++ 不是我的强项，所以我试图复制一个用 Python 编写的程序，该程序大量使用继承，但它比用 C++ 编写要简单得多，因为您没有显式使用指针和引用（在抽象级别是）。