Adding Classes to an Array - c++

Question

I'm working on a university assignment about finding the array of different shapes using OOP.
I have created all of my shape classes so they derive from my main Shape Class. Shape class is being used like an interface, so that all the shape classes derived from the shape class have to have a calculate area function, etc.
I want to create an array of different shapes. I have declared an array with a type of shape, which is the parent class and i want to add new instances of each different shape, circle, square, rectangle and triangle to the array list so that all the information about each shape is stored in one array. I have the follow code but i have an error on the line aShapes[i] = square; saying that shape is an inaccessible base of square.
If anyone could help out that would be great.
Thanks in advanced.
Here is my code
#include <cstdlib>
#include <iostream>
#define M_PI 3.14159265358979323846
using namespace std;
class Shape{
public:
string sName;
float nArea;
void fnAddData();
float fnCalculateArea();
};
class Square : private Shape {
private:
float nSide;
void fnAddData()
{
cout << "Please enter the length of a side: ";
cin >> nSide;
}
float fnCalculateArea(float side)
{
return (side * side);
}
public:
Square()
{
sName = "Square";
fnAddData();
nArea = fnCalculateArea(nSide);
}
};
Shape aShapes[5];
/*
*
*/
int main(int argc, char** argv)
{
int decision;
Square square;
for (int i = 0; i < 5; i++)
{
cout << "Shape number";
cin >> decision;
switch (decision)
{
case 1:
aShapes[i] = square;
}
}
return 0;
}

Answer 1

Arrays aren't polymorphic: Everything stored in the array must be the same type. Your array of Shape won't work.1
So how do you get polymorphism when using an array, then? Change your array to store pointers to Shape:
Shape *aShapes[5];
That solves the problem nicely: A Shape* can point to a Shape or any of its descendants,2 and all the Shape* themselves are the same type.
And then in your main code, store the addresses of the objects in the array:
aShapes[i] = □
You will need to make a couple other changes to your existing code to make this work:
Use public inheritance, not private inheritance.
Make the methods in Shape virtual.
Make the methods in Square that override the interface defined by Shape public.
Add a virtual destructor.
1 If you do manage to copy a descendent of Shape into the array, you end up slicing the object.
2 Technicality: If you give Shape pure virtual methods, you won't be able to create an instance of a pure Shape. In that event, Shape* can't point at an instance of Shape because you can't create one! A Shape* would only point to one of its descendents that implements all of the virtual methods.

Answer 2

The reason you're getting that particular error is because you're using private inheritance when it looks like you really want to be using public inheritance.
class Square : public Shape {
^^^^^^
A further problem is that polymorphism works only with pointers or references. You cannot put a Square into an array of Shapes. It will simply slice out the Shape part of the Square and put that in the array. Shape aShapes[5]; is nothing more than an array of Shapes - there are no Squares, no Triangles, just Shapes. What you need is something like:
Shape* aShapes[5];
You can then set the pointers in this array to point at objects of types that derive from Shape.
You'll also need to make the functions that you want to override in the derived classes virtual. When the compiler sees something like aShapes[0]->fnCalculateArea(), and then sees that fnCalculateArea is a virtual function, it will only then look up the dynamic type of the object that aShapes[0] points to - it will then see that it's a Square and call Square::fnCalculateArea.

Answer 3

1) You're privately inheriting from Shape, which is more typically an undesirable form of composition. You should be publicly inheriting from Shape for your purposes.
class Square : public Shape
2) None of Shape's member functions are declared virtual, so none of them will be overridden by derived classes. You also don't have a virtual destructor. If you want the CalculateArea function of Square to be used when you call it on a Shape pointer that points to a Square, you have to declare as virtual in Shape, and override it in Square:
In Shape:
virtual float fnCalculateArea();
In Square:
void float fnCalculateArea() override;
3) If Shape should act only as an abstract interface, not to be instantiated itself, then you should make it so by making one of its functions pure virtual (the destructor at least, if nothing else).
virtual ~Shape() = 0 {}
4) If you want to store the different derived types in a single container, then you have to store them by reference, IE through a pointer to their base class.
Shape* aShapes[5];
5) I also noticed that you're prefixing many variable names with n even though they are floats. Hungarian notation typically uses n to refer to ints and f to refer to floats.

Answer 4

Arrays of values do NOT behave polymorphically. You will have to use an array of pointers to Shape, as access and assignment to pointers does behave polymorphically.
What you have here is object slicing, you're cutting off the Derived class chunk so that your object fits into a Base. This is bad.
With a pointer, however, you get no slicing.
Your particular error stems from use of private inheritance, which forbids conversion to the inherited class. Use public inheritance. This is just masking the issue above.