C++ Inheritance : Base attributes over various derived objects

Question

I'm currently learning about C++ Inheritance, so if this question is a dumb one, I apologize in advance.

Implementing this scenario:

1. A super class has a color attribute, which can be any color (let's assume color is represented by an integer).

2. Let's assume I have an initialization of this super class, with the color red.

3. I am also going to initialize different objects of a sub-class which also share the color red.

My question is, is there any way that I can initialize this attribute color to red (or any color for that matter) and it would be automatically inherited by objects of it's sub-class, instead of setting the attribute to red every-time I initialize one of these objects?

Again apologies if I'm missing a basic concept here, but I can't seem to find anything online on this.

Pseudo-Code per request:

Super-class code:

class Shape {

    int color;

    Shape::Shape(int c) : color(c) { }  //constructor

}

Sub-Class code:

class Square {

    int length, width;

    Square::Square(int l, int w, int c)
    :    length(l),
         width(w),
         color(c)
    { }
}

class Circle {

    int radius;

    Square::Square(int r, int c)
    :    radius(r),
         color(c)
    { }
}

What I'm trying to say is that both square and circle need to have the same color, is there anyway (maybe from the super class? ) to declare this color (ex. red), and both shapes would have this color set the same?

Answer 1

You could accomplish what you want with a static default_color that gets used when no color is explicitly specified, and gets set whenever a color is specified.

struct Shape {
    static int default_color;
    int color;
    Shape(int c) : color(c)
    {
        default_color = c;
    }
    Shape() : color(default_color) {}
};

Shape::default_color = BLACK;

struct Square : public Shape {
    int length, width;
    Square(int l, int w, int c)
    : Shape(c),
      length(l),
      width(w),
    { }

    Square(int l, int w)
    : length(l),
      width(w)
    { }
}

struct Circle : public Shape {
    int radius;
    Circle(int r, int c)
    : Shape(c),
      radius(r)
    { }

    Circle(int r)
    : radius(r)
    { }
}

int main()
{
    Square sq(2, 3, RED);
    Circle cir(10); // Automatically red, since that's
                       the last color explicitly specified
}

I would say this is a poor design though. Global state like this makes it very easy to make mistakes. You now have to think about the state of the entire program whenever you create a shape. It would be better to simply create the Circle as Circle cir(10, sq.color);. That makes it explicit what color your Circle is, and reduces cognitive load on the programmer.

Answer 2

Prior to C++11, the primary way to do this would be as follows:

class baseClass
{ 
    int color;

    baseClass() { color = RED; }
};

class subClass : public baseClass
{
    subclass() { }
};

With C++11 and later, you can assign the default value in the class declaration:

class baseClass
{ 
    int color = RED;

    baseClass() { }
};

This would be inherited.

EDIT: As mentioned below, the default baseClass constructor is automatically called in this case.

Answer 3

There's a difference between a class and an instance of a class. A class is something like a structure, according to which further instances will be created. A class is something like a description, an instruction how to build objects. Inheritance is related to classes, not to objects. As for fields, the inherited class has all the same fields from the parent class plus some new fields you may add.

A simple example for you:

class MyBase {
public:
    int color;
};

class MyChild : public MyBase {
public:
    double length;
}

int main() {
    MyBase myBaseObj;
    myBaseObj.color = 1;

    MyChild myChildObj;
    myChildObj.color = 2;
    myChildObj.length = 3.14;

    return 0;
}

Answer 4

is there anyway (maybe from the super class? ) to declare this color (ex. red), and both shapes would have this color set the same?

In your posted example, yes. A super-class constructor can set its variables to whatever it wants to, for example:

Shape::Shape(int c) : color(7) { }  // 7 == RED

If Shape had that constructor defined, then instances of every subclass would represent red shapes.

This sample program prints 7, overriding the user's chosen color:

#include <iostream>

class Shape {
public:

    int color;

    Shape(int c) : color(7) { }  //constructor

};

class Square : public Shape {
public:

    int length, width;

    Square(int l, int w, int c)
    :    Shape(c),
         length(l),
         width(w)
    { }
};

class Circle : public Shape {
public:

    int radius;

    Circle(int r, int c)
    :    Shape(c),
         radius(r)
    { }
};

int main() {
    Square q(4,8,0);
    std::cout << q.color << "\n";
}