Question

给定A类和B类。我需要使用cpp文件中所示的“add”函数，将类B的对象引用存储在A类的对象数组中。

我应该可以使用“ - ＆gt;”如cpp文件所示，调用Class B的“print”函数。

编译时错误：void *不是指向对象的指针类型

那我该如何解决这个错误？

=============================================== ===================================

//头文件

// ABC.h

class A{
     private:
        size_t size_;
        void * a_[256];
        static int index_;
    public:
        void add(void * obj);
        void * operator[](int x){
            return a_[x];
        }


};

class B {
    private:
        const char * f_;
        const char * l_;

    public:
        B(const char * fn, const char * loc ):f_(fn), l_(loc){ A(); };
        void print();
};

// cpp file

#include "ABC.h"

int A::index_ = 0;

inline void A::add(void* obj){

    void * insertionPoint = static_cast<char *>(a_[index_]) + ( size_ * index_ );

    memcpy( insertionPoint, obj,  size_);

    ++index_;

}

inline void B::print(){
    ...
}

int main()
{
    A a;

    B b( "Name", "Some string");

    a.add( &b );

    a[0]->print(); // <-- This should be an object reference to B, but it is producing the error.

    return 0;
}

输出：

名称一些字符串

Answer 1

以下方法毫无意义：

virtual void add(A * obj){
    *this = dynamic_cast<void*>(obj);
}

如果您想在A内存储指向A的其他实例的指针，请创建一个指针数组，您将在其中保存它们，尝试“替换”当前实例（即{{1没有意义。

另请注意，如果您要检查*this =是否指向dynamic_cast的实例，A*会有意义：

为什么不从简单的事情开始？让我们说：

A* a = new B();
// in compile time it's A*, but does it really point to instance of B? :
B* b = dynamic_cast<B*>(a);

用作：

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

class B : public A {
public:
    void print() /* const */ { std::cout << "b"; }
};

（原样）输出A* a = new A(); A* b = new B(); a->print(); b->print();。然后，您可以将ab的{{1}}更改为B，并意识到方法的print()实际上非常重要。

Answer 2

该解决方案涉及以上所有评论的建议

比较问题和答案之间的差异，完全看到解决方案。

我需要做的是将A类的私人a_成员改为A型：A * _a [256]
下一步：我需要将operator []和add方法的参数更改为A类：A * operator []（A * obj）
下一步：我需要为A类添加一个虚拟的void print（）用于继承。
最后：B类需要继承A类

以下是工作代码

注意：我不确定此代码是否完全安全或是否正确处理内存问题，但我知道它会打印输出要打印的内容。

=============================================== ===================================

//头文件

// ABC.h

class A{
     private:
        size_t size_;
        A * a_[256];
        static int index_;
    public:
        void add(A * obj);
        A * operator[](int x); // Any subclass object reference of A can be assigned now. 
        virtual void print()const; // Virtual tells the compiler to look for other void print methods first.


};

class B : public A{
    private:
        const char * f_;
        const char * l_;

    public:
        B(const char * fn, const char * loc ):f_(fn), l_(loc){ A(); };
        void print()const;
};

// cpp file

#include "ABC.h"

int A::index_ = 0; // Need to call this here because it is declared static in Class A and can be used dynamically. 

inline A * A::operator[](int x){
    return a_[x]; // Implements operator[], so class A can act like a container.
}

inline void A::add(A* obj){

    a_[index_] = obj; // Adds a base or subclass object reference to class A object array.

    ++index_; // Need this to remember current index of object reference A's array.

}

inline void A::print()const{}

inline void B::print()const{

    std::cout <<  "B " << firstname_ << " works in " << location_ << std::endl;

}

int main()
{
    A a;

    B b( "Name", "Some string");

    a.add( &b );

    a[0]->print();

    return 0;
}

输出：

名称一些字符串

使用公共函数将对象引用传递到不同的类对象数组中

2 个答案: