Where should classes which inherit from a base class be kept within the project?

Question

I have a parent Shape class that has a pure virtual method Area() which prints the area of a given shape and 2 child classes that inherit from this parent class, Square and Circle. Where should I include Square and Circle?

Shape.cpp

#include <string>
class Shape
{
public:
    virtual void Area() = 0;
};


class Square : public Shape
{
private:
    int height, width;
public:
    Square()
    {
        height = 5;
        width = 5;
    }
    // Inherited via Shape
    virtual void Area() override
    {
        printf("%i\n", height * width);
    }
};

class Circle : public Shape
{
private:
    int radius;
public:
    Circle()
    {
        radius = 10;
    }
    // Inherited via Shape
    virtual void Area() override
    {
        double x = pow(radius, 2);
        printf("%lf\n", 3.14 * x);
    }

};

ShapeTest.cpp

#include <iostream>
#include "Shape.cpp"

int main()
{
    Square square{};
    Circle circ{};

    square.Area();
    circ.Area();
}

My preferred option would to include them in their own separate files, something like

• Shape.cpp
• Square.cpp
• Circle.cpp

but I seem to run into link issues with this, so I when I include them under the one file it works.

This would obviously get unwieldy as the number of child classes increases, so what is the correct way to do this?

Answer 1

You indeed should have separate headers and sources for each of the classes, as you desired anyway:

shape.h:

#ifndef SHAPE_H_
#define SHAPE_H_
// (include guard!)

class Shape
{
public:
    virtual void area() = 0;
};
#endif

With a class as simple as above you possibly don't need the source file, but might add further non-pure-virtual functionality, so:

shape.cpp:

#include "shape.h"

// further includes you possibly need

// possibly definition of static class variables
// (if you don't declare them inline)

// implementation of Shape's functions, if there are

square.h:

#ifndef SQUARE_H_
#define SQUARE_H_

#include "shape.h"
// or, depending on how you organize your headers:
// #include <shape.h>

class Square : public Shape
{
private:
    unsigned int height, width;
    // ^ (!) – negative with/height are pretty meaningless, aren't they?
public:
    Square()
        : height(5), width(5) // use initializer list instead!
                              // (not to be confused with std::initializer_list!)
    { }

    virtual void area() override;
};

square.cpp:

#include "square.h"
#include <cstdio> // for printf

void Square::area()
{
    printf("%u\n", height * width);
    //       ^  as I made them unsigned...
    // better: prefer iostreams (std::cout), they are safer
    // (no mismatch between format specifier and data possible)
}

Analogously for Circle...

Note, about area function, though: It should not print the value to to console, instead it should rather return the value in some appropriate format (one of the rare cases where floating point, i.e. double, actually appears suitable…).

Separating classes and IO improves re-usability tremendously (imagine you would want to re-use these classes and show the area in a GUI!).

Answer 2

Your code should look like this:
you only need to include header files, not implementation files. and your implementation should be in cpp files not header files, so just declare the functions in the header files, and implement them in the cpp files, this way its also more readable.

EDIT:
you also need to prevent from including a header file more than once so you do this by:

1. add this line at the top of the .h header file (if the compiler supports it):
   #pragma once
2. else you can do it manually with this syntax:
   file.h

#ifndef FILEH
#define FILEH
// code
#endif

main.cpp

#include <iostream>
#include "Shape.h"
#include "Circle.h"
#include "Square.h"

int main()
{
    Square square{};
    Circle circ{};

    square.Area();
    circ.Area();
}

Shape.h

#pragma once
#include <string>

class Shape
{
public:
    virtual void Area() = 0;
};

Square.h

#pragma once
#include "Shape.h"

class Square : public Shape
{
private:
    int height, width;
public:
    Square()
    {
        height = 5;
        width = 5;
    }
    // Inherited via Shape
    virtual void Area() override;
};

Square.cpp

#include "Square.h"

void Square::Area()
{
    printf("%i\n", height * width);
}

Circle.h

#pragma once
#include "Shape.h"

class Circle : public Shape
{
private:
    int radius;
public:
    Circle()
    {
        radius = 10;
    }
    // Inherited via Shape
    virtual void Area() override;
};

Circle.cpp

#include "Circle.h"

void Circle::Area()
{
    double x = pow(radius, 2);
    printf("%lf\n", 3.14 * x);
}