Question

• I have two classes, A and B
• Class B has a private member variable which is a constant dynamically
  sized array of object A
• One of the constructors for class B will take a constant reference to
  a Class A object which will be used to set the array in class B

class B:

class B
{
  private:
    const A** theArray;
  public:
    B(const A&);
};

B::B(const A& newA)
  : theArray(newA) //<-- ??
{
}

When I try to compile the program, I get an error saying “cannot convert from ‘const A’ to ‘const A **’ “

How would I pass an object into the member initializer list so I could make an array out of them?

edit 1:
This is for a comsci class assignment. We’re learning about classes right now and the assignment has us creating three separate constructors for this particular class (a copy constructor; one to add a new A object into ‘theArray’ in class B; and a constructor that add the first A object into ‘theArray'(this is the constructor in question).)

The idea is that you call the third constructor in the list to create an object. Then if you want to add another A object to the array you would call the second constructor. Then if you wanted a copy of the object you would use the copy constructor.

Answer 1

when I try to compile the program I get an error saying “cannot convert from ‘const A’ to ‘const A **’ “

Then, the first thing you must do is understand the compiler error. What is trying to say the compiler?

In the B constructor you’re initializing a member of the type const A ** with a given parameter of the type const A &; they aren’t of the same type and this is why the compiler is complaining.

So, what to do to fix it?

You must make the B constructor to take the same type of the member variable as argument.

class B
{
private:
    const A** theArray;
public:
    B(const A**);
};

B::B(const A** newA)
    : theArray(newA) //<-- They're of the same type: no problem.
{
}

But you must ensure that the calls outside the class matches the constructor definition.

But instead of it, I advise to revise the design, you’re sure that naked pointers is the only solution to your problem? You must answer this questions in order to improve the class B:

• Where the dynamic memory is created an where is destroyed?
• The class B takes the ownership of the given A**?

If the class B will be the owner of the dynamic memory, you must think about creating and destroying the theArray inside the class B itself not outside.

If the class B will not be the owner of the dynamic memory, you must be very careful about the memory: The memory pointed by theArray will be destroyed after of before the class B? in other words, could be a class B instance with memory pointed by theArray already deleted? In this case, smart pointers could be a good help.