overloaded constructors and inheritence

[ayan4u]

suppose i have...

 
class base
{
public:
         base();
         base( char*);
 
         char* return_string() { return string; }
private:
         char[10] string;
};
 
class derived:public base
{
public:
            derived();
            derived(char* , int);
 
            int returnValue( ) { return value; }     
 
private:
         int value;
};
 
 

now when i define things....

 
 
base::base()
{
memset(string, 0, 10);
}
 
base::base(char* temp)
{
     strcpy(string, temp);
}
 
derived::derived()
{
}
 
 // my question is here...this works
derived::derived(char* temp, int number):base(temp);
{
    value =number;
}
 
 // but this won't work
derived::derived(char* temp, int number)
{
    base(temp);
    value =number;
}    
 
 

[AdrianH]

Use strncpy() not strcpy(). It will cause you greif.

You can only invoke the constructor at creation. Once you have entered the body, it has already been invoked. The second example you gave is a Javaism. Can't do that in C++.


Adrian

[ayan4u]

Use strncpy() not strcpy(). It will cause you greif.

You can only invoke the constructor at creation. Once you have entered the body, it has already been invoked. The second example you gave is a Javaism. Can't do that in C++.


Adrian

thats what i am asking why not....why the second example is not working just like the first....

[AdrianH]

thats what i am asking why not....why the second example is not working just like the first....

Because C++ defines it that way. ;)


Adrian

[JosAH]

thats what i am asking why not....why the second example is not working just like the first....

Now your question boils down to: why isn't "fietsbandventielnippeltje" an English
word? Because it isn't; C++ wasn't designed that way; objects are constructed
from the inside out like onion layers; an outer layer doesn't exist until an inner
layer is fully constructed.

Destruction works the other way around: from the outer layers to the inner layers.

And the C++ syntax for that is that all superlcass stuff has to be done following
the ':' after a constructor signature definition. Sorry, blame Bjarne Stroustrup
for that ;-)

kind regards,

Jos

[DhananjayNangare]

This should work

derived::derived(char* temp, int number)
{
base::base(temp);
value =number;
}

[AdrianH]

This should work

derived::derived(char* temp, int number)
{
base::base(temp);
value =number;
}

If it does, the the world will implode. Good thing it doesn't, eh? :D


Adrian

[DhananjayNangare]

Please try this code

#include <iostream>
 
using namespace std;
 
 
class base
{
public:
         base();
         base( char*);
 
         char* return_string() { return string; }
private:
         char string[10];
};
 
class derived:public base
{
public:
            derived();
            derived(char* , int);
 
            int returnValue( ) { return value; }     
 
private:
         int value;
};
 
 
 
 
 
 
base::base()
{
memset(string, 0, 10);
}
 
base::base(char* temp)
{
     strcpy(string, temp);
 
     cout <<"\n"<< temp;
}
 
derived::derived()
{
}
 
// my question is here...this works
//derived::derived(char* temp, int number):base(temp)
//{
//    value =number;
//}
 
 
derived::derived(char* temp, int number)
{
    base::base(temp);
    value =number;
}
 
 
void main()
{
    derived d("hello",45);
}

[AdrianH]

What compiler are you using? You cannot call a constructor's body in this way. The line base::base(temp); is interpreted as declaring a var called temp with a type called base::base (base type located in the scope of base). Read here for more info.

For an example of this not working, try modifying your code to state what constructor is being called, by couting out at both base constructors. If your compiler is accepting it, it is because it is not telling you about var temp being shadowed. Under g++ this is considered an error.

BTW, main() should always be decared as returning an int.


Adrian

[DhananjayNangare]

What compiler are you using? You cannot call a constructor's body in this way. The line base::base(temp); is interpreted as declaring a var called temp with a type called base::base (base type located in the scope of base). Read here for more info.

For an example of this not working, try modifying your code to state what constructor is being called, by couting out at both base constructors. If your compiler is accepting it, it is because it is not telling you about var temp being shadowed. Under g++ this is considered an error.

BTW, main() should always be decared as returning an int.


Adrian

Thank you for the link. The case which you are refering is quite different from what we are discussing.
I've tried this on VC++ 6.0 and it works absolutely fine.

Could you please justify your statement
"You cannot call a constructor's body in this way. " ??
Please post the Error which you got while compling this code on g++.

Even this is going to work
void main()
{
base::base("hellothere");
}

Here a temporary object will be created.
Also in our case. base::base() will NOT be intepreted as variable declaration.
The case you are talking about is this ( from your refrence link)

Foo x(Bar());
What main should return is secondary.

[AdrianH]

Thank you for the link. The case which you are refering is quite different from what we are discussing.
I've tried this on VC++ 6.0 and it works absolutely fine.

Could you please justify your statement
"You cannot call a constructor's body in this way. " ??
Please post the Error which you got while compling this code on g++.

Even this is going to work
void main()
{
base::base("hellothere");
}

Here a temporary object will be created.
Also in our case. base::base() will NOT be intepreted as variable declaration.
The case you are talking about is this ( from your refrence link)

Foo x(Bar());
What main should return is secondary.

OMG, if it works with VC++ 6.0, then it must be right. LOL ;)

I did try it and low and behold it did work without warnings (no surprise as it is a MS compiler ;)). But even it doesn't do what you think. Try and putting a line like these:

// Place in base::base()
cout << "base::base() called.  this = " << this << endl;
 
// Place in base::base(char *) 
cout << "base::base(char *) called.  this = " << this << endl;
 

Oh, you might also want to put something similar in base's destructor.

It will surprise you by showing you that it is creating a temporary variable. Not calling the constructor on the current instance like it would if you put it where we stated it should be. (BTW, this is not what the standard says it should do which translate roughly into "If it looks like a declaration, it is.")

Under g++ (also not always the best compiler to use for such tests, but IMHO better than VC++) it does get it right in that it thinks that base::base(temp); is a declaration. Though even I was surprised that it would since the type appears to be the constructor, but apparently, base(temp) is equivalent to base::base(temp).

If you want the best test, Comeau is reportedly the best (comp.lang.c++ refer to it quite a bit) in implementing C++ in accordance to the standard. I've not bothered yet to download their compiler, but I will when I get my flaky drive repaired.

The link stating Foo x(Bar()) is only the tip of the iceberg. Foo(x); is equivalent to Foo x; under properly conforming compilers.

Have I justified myself enough?


Adrian