what is the meaning in casting base class constructor to derived class constructor?

Question

class Triangle: public Shape{
      public:
             Triangle(int a=0, int b=0):Shape(a,b){}
             int area()
             {
                 cout << "in triangle class";
                 return width*height/2;
             }
};

in the above code, wt is the meaning of the line

Triangle(int a=0, int b=0):Shape(a,b){}

Answer 1

If Derived class inherits Base class, then when constructing a Derived object, the constructor of Derived class must call the constructor of Base class. The Destructors of these classes will be called in reversed order. In Triangle(int a=0, int b=0):Shape(a,b){}, the Triangle constructor is calling Shape constructor passing the required arguments. There is no casting involved. Check this and this.

Answer 2

Nothing is being cast here. The Triangle constructor is invoking the Shape base class' constructor with the parameter list, (a,b).

Answer 3

There is no cast here. This is a constructor initialization list.

When you construct a Triangle, since Shape is a base class, it must construct a Shape first. The list Shape(a,b) says that a,b are the arguments given to the constructor for this Shape.

Answer 4

Your code:

class Triangle: public Shape{
      public:
             Triangle(int a=0, int b=0):Shape(a,b)
             {
               // may do something
             }

             int area()
             {
                 cout << "in triangle class";
                 return width*height/2;
             }
};

How does internally work:

class Triangle: public Shape{
          public:
                     Triangle(int a=0, int b=0):
                 {
                   // always before the others instructions
                   base(a,b);

                   // may do something
                 }

                 int area()
                 {
                     cout << "in triangle class";
                     return width*height/2;
                 }
    };

There are several ways to work with constructors:

(1) Declare a new class with a new constructor

class NewConstructorClass: public SomeBaseClass // dont care about parent class constructor
{
   NewConstructorClass {
     // do something new instruction 1
     // do something new instruction 2
     // do something new instruction 3
   }

  public:
    void DoAnything()
    {
      // ...
    }
};

(2) Declare a new class with a new and empty, constructor. Some developers do this, in order, to add code to the constructor, later, or, explicitly, add an empty constructor, as a "best practice", to indicate that there should be a constructor.

class NewConstructorClass: public SomeBaseClass // dont care about parent class constructor
{
   NewConstructorClass {
     // does nothing, on purpouse
   }

  public:
    void DoAnything()
    {
      // ...
    }
};

(3) Declare a new class without a new constructor. The compilers adds an automatic constructor that does nothing.

class NewConstructorClass: public SomeBaseClass // dont care about parent class constructor
{
   NewConstructorClass {
     // do something new
   }

  public:
    void DoAnything()
    {
      // ...
    }
};

(4) Declare a new class with a new constructor, that calls the base constructor. Like your scenario:

class NewConstructorClass: public SomeBaseClass // dont care about parent class constructor
{
   NewConstructorClass: base() {
     // do something new
   }

  public:
    void DoAnything()
    {
      // ...
    }
};

Each case, depends, on what you want to achieve. Some of this cases, may be consider "Bad practices", others "good practices", depending on coding styles.

Cheers.