问题

让成员函数返回类型成为您要返回的实际对象的超类的正确方法是什么？

问题

Clang tidy 警告我返回subClassA或subClassB丢弃我对myMethod. 我也没有得到任何输出 - 大概是因为我不小心丢弃了覆盖的myMethod.

编码

#include <iostream>

using namespace std;

class SuperClass {
public :
    SuperClass() {
        cout << "I'm the superclass" << endl;
    };

    virtual std::string myMethod();
};

class SubClassA : public SuperClass {
public:
    SubClassA() : SuperClass() {
        cout << "I'm subclass A" << endl;
    }

    std::string myMethod() override {
        return "A";
    }
};

class SubClassB : public SuperClass {
public:
    SubClassB() : SuperClass() { …

在下面的示例中，我有我的父类和两个子类。任何一个孩子的对象都存储在父母的向量中。循环遍历向量我只能看到来自父类的方法调用。

如何正确获得方法定义和 vtables 以及如何避免切片效应。我一直在做 Python 太长时间了，这样的事情会起作用。

#include <iostream>
#include <vector>


using namespace std;

class A{
    public:

        virtual string print(){return string("A");};
};

class B: public A{
    virtual string print() final {return string("B");};
};

class C: public A{
    virtual string print() final {return string("C");};
};

int main()
{

   vector<A> v;
   v.push_back(B());
   v.push_back(C());

   for(auto x : v){
       cout << x.print() << endl;
   }

}

=>

$g++ -std=c++11 -o main *.cpp
$main
A
A

我在父类向量中有多个子类，其中每个子类都有自己的类型。父级有一个虚getType函数，每个子级都用它自己的覆盖它；甚至不确定我是否需要这个 TBH，但我从父类 C++ 中的这个Access 子成员那里得到了

当我循环遍历向量（此处未显示循环）时，类型只是父对象的类型，因为它是父对象的向量，但我需要使用它自己的构造函数创建的每个子对象的类型。

#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Parent 
{
  private:
  string type = "parent";
  public:
    virtual string getType()
    {
      return type;
    }

};
class Child1 : public Parent
{
  string type = "type1";
  public:
    string getType()
    {
      return type;
    }
};
class Child2 : public Parent
{
  string type = "type2";
  public:
    string getType()
    {
      return type;
    }
};
//main.cpp
int main()
{
   vector<Parent> children; …

我知道有虚函数，但没有虚变量。没有添加它可能是因为大部分时间不需要它，但我最近遇到了一个问题：

class A
{
public:
    int bar;
};

class B : public A
{
public:
    float foo;
};

class C : public A
{
public:
    double foo;
};

int main()
{
    std::vector<A*> v;
    v.push_back(new B());
    v.push_back(new C());

    std::cout << v[1]->bar << v[0]->foo; //error because it will not find 'foo' in A
}

无论如何，我可以阻止这个错误吗？

下面是C++中虚拟函数最简单的例子:

#include <iostream>

class A {
public:
    virtual void f() {
        std::cout << "A";
    }
};

class B : public A {
public:
    void f() {
        std::cout << "B";
    }
};


int main() {
    {
        // calls f() in derived class
        A* a = new B();
        a->f();
    }
    {
        // calls f() in base class
        A a = B();
        a.f();
    }
}

这个程序的输出是BA.我期待它BB,即在任何情况下调用基类.为什么使用基类指针会有所不同？我没有在标准中找到解释.

是否可以在不使用指针的情况下在任何std c++ 容器中维护派生类的知识，动态地从容器转换返回值？我知道我可以创建一个向量或一些基类类型的指针，并让它们保留它们的子类。但问题是我必须使用指针吗？

例子：

struct A {
  int x = 0, y = 0, z = 0;
  virtual void foo() { cout << "A" << endl; };
};

struct B : public A {
  int a = 1, b = 1, c = 1;
  virtual void foo() { cout << "B" << endl; };
};

int main() {  
  <SOMECONTAINER><A> a(2);
  a[0] = A();
  a[1] = B();
  B * p;
  B& n = dynamic_cast<B&>(a[1]); // Always throws?
  p = …

我有一个类型为A的对象列表,它可能包含从A派生的任意数量的类的实例.我在列表的每个成员上调用一个函数,并希望调用最派生类的函数.但是,调用基类的功能.我怎样才能得到使用派生程度最高的类的情况？

以下代码说明了我的问题.代码输出"In a"但我希望它输出"In b".

#include <iostream>

class A {
public:
    virtual void func()
    {
        std::cout << "In A" << std::endl;
    }
};

class B : public A {
public:
    virtual void func()
    {
        std::cout << "In B" << std::endl;
    }
};

int main()
{
    A a = B();
    a.func();
    return 0;
}

我有继承这个问题,我无法解决这个问题.我有三个班,他们之间有父母关系.它们都具有calcForces()函数.

class Object {
public:
    virtual void calcForces();
};


class Boat : public Object {
public:
    virtual void calcForces();
};


class Sailboat : public Boat {
public:
    void calcForces(Wind wind);
};

现在我的问题是II有一个创建为Sailboat的对象(并将其保存在Object-pointer中),但是当我调用calcForces()时,我最终在Boat :: calcForces()中,而不是Sailboat :: calcForces().我究竟做错了什么？

这是我对函数的调用:

(*this->object_ptr_arr[i]).calcForces();    //'object_ptr_arr' is of type 'Object**'