«

I have two classes:

aule_gl_window (parent class)

and

aule_button (sub class)

I want to call the super class (parent) constructor code from the sub
class constructor.

I am trying this:

aule_button::aule_button()
{
aule_gl_window::aule_gl_window();
}

and it does not work at all.

Any ideas?

Cheers!

On Fri, 27 Jun 2003 20:44:44 -0700, Robin Forster wrote:

> I have two classes:
>
> aule_gl_window (parent class)
>
> and
>
> aule_button (sub class)
>
> I want to call the super class (parent) constructor code from the sub
> class constructor.
>
> I am trying this:
>
> aule_button::aule_button()
> {
> aule_gl_window::aule_gl_window();
> }
>
> and it does not work at all.
>
> Any ideas?

When you instantiate the sub-class (derived class), the parent class' ctor
is called automatically before the derived class' ctor. You could call it
explicitly by writing it in the member initialization list, like:

aule_button::aule_button(): aule_gl_window() { }

HTH,
-Dhruv.

Robin Forster wrote:

> I have two classes:
>
> aule_gl_window (parent class)
>
> and
>
> aule_button (sub class)
>
> I want to call the super class (parent) constructor code from the sub
> class constructor.

There is no need to. The default constructors of every base class and
every member variable of class type are called automatically. If you
want a non-default constructor to be called instead, you can specify
that in the initializer list.

aule_button::aule_button()
: aule_gl_window(the, parameters)
{
}

> I am trying this:
>
> aule_button::aule_button()
> {
> aule_gl_window::aule_gl_window();
> }
>
> and it does not work at all.

Note that "does not work at all" is not a useful error description.

FYI, I was playing with inheritance yesterday to test how/whether the
child constructor/destructor would call those of the parent. Below is my
test code. Obviously I found out what people have been telling you: That
the child's constructor calls the parent's default constructor
automatically unless otherwise specified in the initializer list.

The attempt to call the parent's default constructor *outside* the
initializer list and actually in the body of the child's constructor bit
me, too (i.e., it did not initialize the child's data members). You said
that "did not work".

Suzanne
-------------------------------------------------------------------------------
// http://www.cs.unc.edu/~vogel/playpen...nheritance.cpp
/************************************************** ****************************
* File: Inheritance.cpp
* Purpose: Test inheritance, with use of parent's constructor and
destructor.
************************************************** ****************************/
#ifndef _STD_USING
#define _STD_USING // Must be #define'd in order to include stddef.h.
#endif // _STD_USING

#include <iostream>

class Parent {
public:
static const int filler = 99;
int* ints;
int n;
int magicNumber;
public:
Parent(const int n=10) {
std::cout << "Parent constructor #1\n";
this->n = n;
this->ints = new int[n];
for (int i=0; i<this->n; i++) {
this->ints[i] = Parent::filler;
}
this->magicNumber = -1;
}
Parent(const int n, const int m) {
std::cout << "Parent constructor #2\n";
this->n = n;
this->ints = new int[n];
for (int i=0; i<this->n; i++) {
this->ints[i] = Parent::filler;
}
this->magicNumber = m;
}
~Parent() {
std::cout << "Parent destructor\n";
delete[] this->ints;
}
};

class Child : public Parent {
public:
Child(const int n=10) {//: Parent(n) { // Parent default
constructor called automatically!
std::cout << "Child constructor #1\n";
}
Child(const int n, const int m) : Parent(n,m) { // Call parent
constructor!!!
std::cout << "Child constructor #2\n";
//Parent:arent(n,m); // This is *not* valid!
}
~Child() { // Parent destructor is called automatically!
std::cout << "Child destructor\n";
}
};

int main(int argc, char** argv) {

// 1. Test whether parent destructor is called automatically (it is).
Child* c0 = new Child();
int* a = c0->ints;
delete c0;

if (a[0]==Parent::filler) {
std::cout << "ERROR: Child not deleted!\n"; // Not printed out
(Good!)
}
std::cout << a[0] << "\n"; // Senseless number (Good!)

//-------------------------------------------------------------------------
// 2. Test whether parent constructor is called automatically (it is),
// and how. Turns out the *default* parent constructor is called
automatically,
// unless the child calls another constructor *before* the block {}.

std::cout <<
"//--------------------------------------------------------\n";
Child* c1 = new Child(99, 10);
int* b = c1->ints;

std::cout << "magic number: " << c1->magicNumber << "\n";
std::cout << b[0] << "\n";
delete c1;

return 1;
}

"Dhruv" <> wrote...
> On Fri, 27 Jun 2003 20:44:44 -0700, Robin Forster wrote:
>
> > I have two classes:
> >
> > aule_gl_window (parent class)
> >
> > and
> >
> > aule_button (sub class)
> >
> > I want to call the super class (parent) constructor code from the sub
> > class constructor.
> >
> > I am trying this:
> >
> > aule_button::aule_button()
> > {
> > aule_gl_window::aule_gl_window();
> > }
> >
> > and it does not work at all.
> >
> > Any ideas?
>
> When you instantiate the sub-class (derived class), the parent class' ctor
> is called automatically before the derived class' ctor. You could call it
> explicitly by writing it in the member initialization list, like:
>
> aule_button::aule_button(): aule_gl_window() { }

This technique is called "initialisation of base classes", not
"calling constructors explicitly". Please do not confuse others.
Constructors cannot be called.

Victor

Thanks for the input. I am inferring that the following is a
possibility:

sub class:

aule_button::aule_button(int width, int height): aule_gl_window(TYPE,
width, height)
{
etc...
}

where TYPE is some constant that initializes a super class instance
variable.

Suzanne Vogel wrote:

> Rolf,
>
> Thanks for your tips. I didn't expect to get tips when I posted my
> code.

When I answer postings that contain source code, I always give tips if I
can, even if they weren't asked for. I hope not to look too much like a
smartass by doing so. I just want to help clear things up.

> Rolf Magnus wrote:
>> Suzanne Vogel wrote:
>>>#ifndef _STD_USING
>>>#define _STD_USING // Must be #define'd in order to include stddef.h.
>>>#endif // _STD_USING
>>
>> Er, what?
>
> On my computer, if I don't write "#define _STD_USING" before trying to
> include stddef.h (or some other header files), I get an error that the
> "exit()" function is not defined.

Hmm. Sounds strange.

>> It's not really useful to declare a function or constructor as taking
>> a const parameter by value, since the function body cannot change the
>> argument that's passed to it anyway.
>
> Oh.
>
>> You could (and should) put initializations in an initializer list.
>> Also note that this->... isn't needed.
>
> I use "this->" before each data member only as a means of documenting
> my code, to denote that I'm using data members and not local function
> variables. Some people document data members by naming them with
> something like "m_[something]", but I don't to modify the names of the
> data members so I simply modify my syntax of how I access them
> ("this->"). Other suggestions welcomed...

I see. Would be too much typing for my taste

>>>int main(int argc, char** argv) {
>>>
>>> // 1. Test whether parent destructor is called automatically (it
>>> is). Child* c0 = new Child();
>>> int* a = c0->ints;
>>> delete c0;
>>>
>>> if (a[0]==Parent::filler) {
>>
>>
>> That's not a good idea. If the parent part is deleted (which it is),
>> you are trying to access memory that doesn't belong to your program
>> anymore. Depending on your platform and the "situation" or maybe on
>> the moon phase, a[0] might still be set to Parent::filler, or it
>> might be overwritten with something else, or your program might get
>> terminated because you're not allowed to access that memory anymore,
>> or anything else can happen. DON'T do that!
>
> I did it just as a test to see whether the parent destructor was
> properly selected. I *knew* that if the data came back senseless (as
> it did), then the parent destructor had been selected. (The opposite
> would not necessarily be true, as you pointed out: It is *not*
> necessarily true that if the data did not come back senseless, then
> the parent destructor had not been selected.)

Ok. I just wanted to note that nobody should expect your test to show
what really happens. It might be the case on your OS/compiler
combination, but this can be different on other systems.

>> aule_button::aule_button(): aule_gl_window() { }
>
> This technique is called "initialisation of base classes", not
> "calling constructors explicitly". Please do not confuse others.
> Constructors cannot be called.
>
> Victor

Ok.

-Dhruv.