By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
445,820 Members | 1,189 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 445,820 IT Pros & Developers. It's quick & easy.

another bloody basic question

P: n/a
In java, one constructor can call another constructor through this(...)

for instance

class foo
{
public:
foo(int k) { this(k,false)};
foo(int k, boolean m){...};
}

It seems i can't find similar syntax in c++.
what is the notion for one constructor to call another?

sorry for this bloody basic question.

jesse

Jul 19 '05 #1
Share this Question
Share on Google+
7 Replies


P: n/a
jesse wrote:
what is the notion for one constructor to call another?


The short answer is you cannot do it directly. Take a look at:
http://www.parashift.com/c++-faq-lit....html#faq-10.3

I think bookmarking the entire FAQ would be a good idea.

Regards,
Janusz

Jul 19 '05 #2

P: n/a
jesse wrote:
In java, one constructor can call another constructor through this(...)

for instance

class foo
{
public:
foo(int k) { this(k,false)};
foo(int k, boolean m){...};
}

It seems i can't find similar syntax in c++.
what is the notion for one constructor to call another?

sorry for this bloody basic question.
...


There's no such syntax in C++. In some cases the common code can be
transferred from constructors to a separate function (regular function,
not a constructor), which then can be called from all constructors. In
other cases there is no other way but to repeat the same code in all
constructors.

--
Best regards,
Andrey Tarasevich

Jul 19 '05 #3

P: n/a
On Wed, 05 Nov 2003 18:12:54 -0800, jesse <je*****@yahoo.com> wrote:
In java, one constructor can call another constructor through this(...)

for instance

class foo
{
public:
foo(int k) { this(k,false)};
foo(int k, boolean m){...};
}

It seems i can't find similar syntax in c++.
what is the notion for one constructor to call another?

sorry for this bloody basic question.


Basically you can't. The C++ construction model is very different to
Javas. By the time you enter the {} part of your constructor, all base
classes and all member variables have already been constructed. This
is because of the existence of user-defined value types, a concept
that Java doesn't have.

Have you come across initializer lists?

foo(int k)
:m_k(k)
{}

foo(int k, boolean m)
:m_k(k), m_m(m)
{}

With initializer lists, the constructor body is often empty anyway, so
what is there to share?

That said, I think a syntax like this has been proposed at some point
in the past, but I don't think any compiler supports it:

foo(int k)
:foo(k, false)
{
//anything extra
}

Tom
Jul 19 '05 #4

P: n/a
On Wed, 05 Nov 2003 18:12:54 -0800, jesse wrote:
In java, one constructor can call another constructor through this(...)

for instance

class foo
{
public:
foo(int k) { this(k,false)};
foo(int k, boolean m){...};
}

It seems i can't find similar syntax in c++.
what is the notion for one constructor to call another?


You can make an init() function that is called from the constructors,
though for your example the simplest would be:

class Foo {
public:
Foo(int k, bool m = false);
}

When you call do new Foo(42) the default is used for m since you didn't
supply a value.

--
NPV

"the large print giveth, and the small print taketh away"
Tom Waits - Step right up

Jul 19 '05 #5

P: n/a
"tom_usenet" <to********@hotmail.com> wrote in message
news:44********************************@4ax.com...
On Wed, 05 Nov 2003 18:12:54 -0800, jesse <je*****@yahoo.com> wrote:
In java, one constructor can call another constructor through this(...)

for instance

class foo
{
public:
foo(int k) { this(k,false)};
foo(int k, boolean m){...};
}

It seems i can't find similar syntax in c++.
what is the notion for one constructor to call another?

sorry for this bloody basic question.


Basically you can't. The C++ construction model is very different to
Javas. By the time you enter the {} part of your constructor, all base
classes and all member variables have already been constructed. This
is because of the existence of user-defined value types, a concept
that Java doesn't have.

Have you come across initializer lists?

foo(int k)
:m_k(k)
{}

foo(int k, boolean m)
:m_k(k), m_m(m)
{}

With initializer lists, the constructor body is often empty anyway, so
what is there to share?


The equivalent in C++ is to use the initializer list to indicate the
constructor of the base class to be used. It is selected by the normal
overloading operation.
Here is a simple example showing construction of a derived class with no,
one, or two arguments.

#include <iostream>
using namespace std;

class B
{public:
int b;
B( ):b(2){}
B(int x):b(x){}
};
class A : public B
{public:
int a;
A( ):a(1){}
A(int x):a(x){}
A(int x, int y):a(x),B(y){}
};
int main ( )
{
A myA;
cout <<myA.a<<myA.b<<endl;
A myA1(3);
cout<<myA1.a<<myA1.b<<endl;
A myA2(4,5);
cout << myA2.a<<myA2.b<<endl;
return 0;
}

--
Gary
Jul 19 '05 #6

P: n/a

"jesse" <je*****@yahoo.com> wrote in message news:3F**************@yahoo.com...
It seems i can't find similar syntax in c++.
what is the notion for one constructor to call another?


There is no similar syntax in C++. You can't call constructors in C++.
The cleanest work around is to put the common code in a seperate
member function and call it from both constructors.
Jul 19 '05 #7

P: n/a

"Andrey Tarasevich" <an**************@hotmail.com> wrote in message news:vq************@news.supernews.com...

There's no such syntax in C++. In some cases the common code can be
transferred from constructors to a separate function (regular function,
not a constructor), which then can be called from all constructors. In
other cases there is no other way but to repeat the same code in all
constructors.


There's nothing that ever prevents the constructor body from being
moved. What's a pain in the butt is that there is no way to share
the initializer lists between two constructors.
Jul 19 '05 #8

This discussion thread is closed

Replies have been disabled for this discussion.