2

I was messing around with inheritance in C++ and wanted to know if anyone had any insight on the way it functions. Code below

#include <iostream>
using namespace std;

class AA {
 int aa;
 public:
 AA() {cout<<"AA born"<<endl;}
~AA(){cout<<"AA killed"<<endl;} 
virtual void print(){ cout<<"I am AA"<<endl;}
};

class BB : public AA{
 int bb;
 public:
 BB() {cout<<"BB born"<<endl;}
~BB() {cout<<"BB killed"<<endl;}
 void print() {cout<<"I am BB"<<endl;}
};

class CC: public BB{
 int cc;
 public:
 CC() {cout<<"CC born"<<endl;}
~CC(){cout<<"CC killed"<<endl;}
 void print() {cout<<"I am CC"<<endl;}
};


int main()
{
 AA a;
 BB b;
 CC c;
 a.print();
 b.print();
 c.print();     
 return 0;
}

so I understand that when you inherit something you inherit constructors and destructors. So when I do , "BB b" it prints "AA born". So the question I have

  1. Is an instance of AA created
  2. If yes, what is it called and how can I reference it?
  3. If no, why is the constructor being called
Improve this question
5
  • 2
    "Is an instance of A created" - I assume you mean AA? Commented Sep 21, 2011 at 20:19
  • so a followup question, if AA had a private member/function, would b.AA::privatefunction() be valid?? Commented Sep 21, 2011 at 20:32
  • 4
    No, it wouldn't be. Outside of a class only friends can touch private parts. If it was protected then it would be valid within BB, but not from within main. Commented Sep 21, 2011 at 20:35
  • 1
    @awoodland upvote for "only friends can touch private parts" Commented Sep 21, 2011 at 21:29
  • 1
    @Mranz - that's one of my favorite C++ phrases. Nobody ever forgets private and friend after that :) Commented Sep 21, 2011 at 21:31

7 Answers 7

Reset to default
2

Inheritance implements the "IS-A" relationship. Every BB is therefore also an AA.

You can see this in a number of ways, the easiest to demonstrate is:

BB b;
AA *aptr = &b;

Here your BB instance b is being pointed at by a pointer which only thinks of itself as pointing to an AA. If BB didn't inherit from AA then that wouldn't be legal.

The interesting thing is that when you call:

aptr->print();

It still prints "I am BB", despite the fact that the pointer you used is of type AA *. This happens because the print() method is virtual (i.e. polymorphic) and you're using a pointer. (The same would also happen with a reference too, but the type must be one of those for this behaviour to happen)

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

2
  1. Is an instance of A created

Sort of. The BB b; code will allocate a BB instance. Part of that object is an AA.

  1. If yes, what is it called and how can I reference it?

Assuming the BB b; variable declaration, your part-of-BB AA instance is called b. If you want to call specific methods in AA that are hidden by BB methods, such as .print(), you need to invoke them like so:

BB b;
b.AA::print();
Improve this answer

3 Comments

so a followup question, if AA had a private member/function, would b.AA::privatefunction() be valid??
you cannot call object private function, only this object can do this
@noob: that syntax is valid for private functions anywhere the private call is allowed (e.g. inside member functions). Note that inside a member function, you can invoke it as this->AA::privatefunction(), or simply AA::privatefunction().
2

BB is an instance of AA. You don't need to access anything special, because you already have that type.

When BB inherits from AA, here's how it's constructed.

  1. Call AA constructor
  2. Initialize member fields
  3. Call BB constructor

When destruction happens, this happens in reverse.

  1. Call BB destructor
  2. Destroy member fields (specific to BB)
  3. Call AA destructor

Oh, and you have at least one virtual function inside of AA. That means you need to make AA's destructor virtual (or bad things will happen).

Improve this answer

3 Comments

The destructor only needs to be virtual if it's going to be deleted virtually. In this case it doesn't matter at all, the behaviour is well defined. (I.e. it's only bad if you use new+delete and you call delete on a pointer to a base rather than the most derived).
@awoodland: how can you guarantee that this object won't be deleted virtually? so this recommendation is good, this should be default implementation even in such simple examples
You can't be sure it won't, but the current wording implies that the behaviour of this code as it stands is undefined, which it isn't. It's a rule of thumb, not a requirement, which is not clear from the wording.
1

In object-oriented languages, there are two main ways of creating objects that inherit from another one: concatenation and delegation. The first one is the most popular, the second is used in prototype-based languages.

Concatenation means that when B inherits from A, there are two parts in the object: in the first part of the object (of length equal to the size of A), the attributes (member variables/fields in C++) of A live. In the other part, there lives whatever attributes B adds to the object. Constructors for each involved class (A and B) are executed so all parts (all attributes) are initialized correctly.

Though the object is managed as a single unit, you can point it with a pointer of class A. In that case, the pointer only lets you see the first part, the part pertaining to class A (i.e. its attributes), but not the attributes from B, since the pointer can only see from the beginning to beginning + size of class A.

Say class A contains an integer x:

class A {
public: int x;
};

and B contains an integer y:

class B: public A {
public: int y;
} obB;

This means that an object of class B will have a length of 8 bytes (for 32 bits), the length of x plus the length of y, while the length of A is of only 4 bytes, the length of x. A pointer of class A to objB:

A * ptrA = &objB;

will only see x,

cout << ptrA->x << endl;
cout << ptrA->y << endl; // ERROR

while a pointer to B:

B * ptrB = &objB;

will be able to access both, x and y:

cout << ptrB->x << ',' << ptrB->y << endl;

In order to completely understand this, you need to know that ptrB->y is roughly translated into *( ( (int *) ptrB ) + 1 ), but that's another story.

Hope this helps.

Improve this answer

Comments

0

A class that derives from a base class contains that base class as a subclass, so an instance of the derived class contains a base subobject.

The subobject is constructed first. The constructor that is used for that is yours to determine: If you don't say anything, the default constructor is used; otherwise, the constructor that you specify in the base initializer list is called. Example:

struct Base
{
  Base() { }             // default constructor
  Base(int, double) { }  // some other constructor
  char q; 
};

struct A : Base
{
};

struct B : Base
{
  B() : A(12, 1.5) { }
};

Both A and B contain Base as a subclass. When you say A a;, the subobject's default constructor is called. When you say B b, the subobjects other constructor is called, because you said so.

As a consequence, if the base class has no accessible default constructor, then you must specify an accessible constructor explicitly.

You can reference members of the subobject by qualifying the name: a.Base::q or b.Base::q. If the name is unambiguous, that's the same as just a.q and b.q. However, when you deal with overridden or hidden member functions (and maybe multiple virtual inheritance), being able to specify the subobject explicitly may be useful or even necessary.

Improve this answer

Comments

0

This is a little easier to understand when I give the structs more meaningful names:

class Animal;
class Dog : public Animal;
class Beagle : public Dog;

[When I create a Dog b...]

  • Is an instance of Animal created?

    Yes, creating a Dog also creates an Animal, because the Dog is an Animal.

  • If yes, what is it called and how can I reference it?

    The Dog b is the Animal instance. If you wanted to explicitly call the Animal versions of the method, you could use b.Animal::print() to tell the compiler to explicitly call the Animal version of the function.

  • If no, why is the constructor being called?

    The Dog b is an an Animal, so constructing a Dog also constructs itself as an Animal.

http://coliru.stacked-crooked.com/a/522371508982b56f

Improve this answer

Comments

-1

Inheritance in c++ means the ability of objects in one class to inherit properties of another class which implements the reusablity concept. This means that it is not necessary to create a new methods and just override the existing one, if required. Saves a lot of work.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.