c++ - 如何从指向基类类型的指针调用派生类函数 (C++)

Question

上下文:我正在为嵌入式应用程序开发通信协议(protocol)。
该协议(protocol)基本上需要是一个包装器，允许它移植到不同的通信方法(串行、WiFi、蓝牙等)，并能够支持与不同外设(DAC、加速度计等)的通信和控制。

想法是每个通信方法(在我的示例中为 A_base)将有自己的实现，同时具有相同的外部功能，这样外围设备的代码就不需要重写，如果(例如)我们从 bytes-over-serial 转移到 json-over-wifi。
每个外围设备都实现了基类(在我的示例中为 B_base)的派生来处理特定于该外围设备的数据传输，因此每个 B 都必须能够调用来自A_base 的导数，而不必知道使用了哪个导数。

当我编译以与下面相同的方式编写的代码时，出现如下错误:

derivedB.cpp: 在成员函数 'virtual void derivedB::setupData()' 中:
derivedB.cpp:xx: 错误:没有匹配函数来调用 'A_base::callFromB(const char*, int&)'
then
baseClasses.h:xx:yy: 注意:候选:virtual void A_base::callFromB()
虚拟无效 callFromB() =0;
候选人需要 0 个参数，提供 2 个参数

我是否实现了我描述的错误功能，或者根本不可能，或它是否需要特定版本的 C++？
我不是经验丰富的 C++ 程序员，因此非常感谢任何帮助。

示例代码:

基础类

/* ==== baseClasses.h ==== */
#ifndef BASECLASSES_H
#define BASECLASSES_H
#include <list>

// forward declarations
class A_base;
class B_base;

class A_base {
protected:
    std::list<B_base*> listOfBs;

public:
    A_base();
    void addB(B_base*);
    virtual void callFromB() =0;
    virtual void alsoCallFromB(short*, int) =0;
    virtual void alsoCallFromB(int*, int) =0;
    virtual void alsoCallFromB(float*, int) =0; // overloaded
};

class B_base {
protected:
    int someCommonInt;
    A_base* A;

public:
    B_base(int, A_base&);
    virtual void setupData() =0;
};

#endif

/* ==== baseClasses.cpp ==== */
#include "baseClasses.h"

A_base::A_base() {}
void A_base::addB(B_base* b { listOfBs.push_back(b); }

B_base::B_base(int i, A_base& ref_A) {
    someCommonInt = i;
    A = &ref_A;
    A->addB(this);
}

A的导数

/* ==== A_derived.h ==== */
#include "baseClasses.h"

class derivedA : public A_base {
public:
    virtual void callFromB(const char*, int);
    virtual void alsoCallFromB(short*, int);
    virtual void alsoCallFromB(int*, int);
    virtual void alsoCallFromB(float*, int); // overloaded
};

/* ==== A_derived.cpp ==== */
#include "A_derived.h"

void derivedA::callFromB(const char* msg, int foo) {
    // do something with msg and foo
}

void derivedA::alsoCallFromB(short* data, int len=1) { // overloaded derived function with default value
    // do something with short int data
}

void derivedA::alsoCallFromB(int* data, int len=1) { // overloaded derived function with default value
    // do something with int data
}

void derivedA::alsoCallFromB(float* data, int len=1) { // overloaded derived function with default value
    // do something with float data
}

B的导数

/* ==== B_derived.h ==== */
#include "baseClasses.h"

class derivedB : public B_base {
private:
    int* intData;
    float* floatData;
    int arraySize;

public:
    virtual void setupData(int*, float*, int);
    void callAWithDataArrays();
    void callAWithSingleValue(int);
};

/* ==== B_derived.cpp ==== */
#include "B_derived.h"

void derivedB::setupData(int* iPtr, float* fPtr, int size) {
    intData = iPtr;
    floatData = fPtr;
    arraySize = size;
    A->callFromB("B setup done.\n", 0);
}

void derivedB::callAWithDataArrays() {
    A->alsoCallFromB(intData, arraySize);
    A->alsoCallFromB(floatData, arraySize);
}

void derivedB::callAWithSingleValue(int idx) {
    A->alsoCallFromB(intData[idx]);
    A->alsoCallFromB(floatData[idx]);
}

主程序

#include "A_derived.h"
#include "B_derived.h"

int main(int argc, char** argv) {
    int myInts[] = new int[8];
    float myFloats[] = new float[8];
    float anotherFloat = 1.23;

    A_derived myA;
    B_derived myB(1337, (A_base&)myA);
    myB.setupData(myInts, myFloats, 8);

    myB.callAWithDataArrays();
    myB.callAWithSingleValue(4);

    return 0;
}

Answer 1

你有一个纯虚函数 virtual void callFromB() =0; 没有在派生类中被覆盖，即:

virtual void callFromB(const char*, int); != virtual void callFromB() 

您可以将 A_base::callFromB() 更改为 A_base::callFromB(const char*, int)