Pass object reference into different class object array using public function - c++

Question

Given class A and Class B. I need to use the "add" function as shown in the cpp file to store an object reference of class B in an object array of class A.
I should be able to use "->" as shown in the cpp file to call Class B's "print" function.
Compile Time Error: void* is not a pointer-to-object type
So how do I solve this error?
==================================================================================
// header file
// 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;
}
Output:
Name Some string

Answer 1

The following method makes no sense:
virtual void add(A * obj){
*this = dynamic_cast<void*>(obj);
}
in case you want to store pointers to other instances of A within A, create an array of pointers where you will hold them, trying to "replace" the current instance (i.e. *this =...) makes no sense.
Also note that dynamic_cast would make sense if you want to examine whether A* points to instance of B:
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);
Why don't you start with something simpler? Let's say:
class A {
public:
virtual void print() { std::cout << "a"; }
};
class B : public A {
public:
void print() /* const */ { std::cout << "b"; }
};
used as:
A* a = new A();
A* b = new B();
a->print();
b->print();
which (as it stands) outputs ab. Then you can change the B's print() to const and realize that the constness of method actually matters.

Answer 2

The solution involved advice from all above comments
Compare the differences between the question and answer to see the solution, fully.
What I needed to do was change class A's private a_ member to type A: A * _a[256]
NEXT: I needed to change the operator[] and the add method's parameter to type A, as well: A * operator[](A * obj)
NEXT: I needed to add a virtual void print()for inheritance purposes to class A.
FINALLY: Class B needed to inherit class A
Below is working code
NOTE: I am not sure if this code is entirely secure or deals with memory issues properly, but I do know that it prints to output what it was intended to print.
==================================================================================
// header file
// 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;
}
Output:
Name Some string