reusing super class constructor code

Discussion in 'C++' started by Robin Forster, Jun 28, 2003.

  1. 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!
    Robin Forster, Jun 28, 2003
    #1
    1. Advertising

  2. Robin Forster

    Dhruv Guest

    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.
    Dhruv, Jun 28, 2003
    #2
    1. Advertising

  3. Robin Forster

    Rolf Magnus Guest

    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.
    Rolf Magnus, Jun 28, 2003
    #3
  4. 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/c /std/Inheritance/Inheritance.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 = 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 = 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::parent(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;
    }
    Suzanne Vogel, Jun 28, 2003
    #4
  5. "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
    Victor Bazarov, Jun 28, 2003
    #5
  6. 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.
    Robin Forster, Jun 28, 2003
    #6
  7. Robin Forster

    Rolf Magnus Guest

    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.
    Rolf Magnus, Jun 29, 2003
    #7
  8. Robin Forster

    Dhruv Guest


    >> 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.
    Dhruv, Jun 29, 2003
    #8
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Guest

    super.super.super how?

    Guest, Feb 19, 2005, in forum: Java
    Replies:
    24
    Views:
    10,758
    Darryl Pierce
    Feb 24, 2005
  2. Fernando Rodriguez

    Getting the super class via the super() function

    Fernando Rodriguez, Nov 21, 2003, in forum: Python
    Replies:
    2
    Views:
    720
    Bob Willan
    Nov 22, 2003
  3. Kerim Borchaev

    super. could there be a simpler super?

    Kerim Borchaev, Jan 15, 2004, in forum: Python
    Replies:
    4
    Views:
    476
    Michele Simionato
    Jan 15, 2004
  4. fi3nd
    Replies:
    0
    Views:
    382
    fi3nd
    Apr 8, 2010
  5. Matthew Braid

    $class::SUPER as well as $instance::SUPER?

    Matthew Braid, Aug 6, 2004, in forum: Perl Misc
    Replies:
    2
    Views:
    307
    Matthew Braid
    Aug 9, 2004
Loading...

Share This Page