Syntax of constructors of inherited classes calling the original constructor

[lars.uffmann]

I have to work on a rather big project that a bunch of people wrote and
that has no useful documentation at all, my C++ has rusted in a bit,
now I stumbled over a constructor that looks something like the below
and have no idea what to do with it :)

inheritedClass: :inheritedClass ([...bunch of arguments...])
: originalConstru ctor ([...bunch of arguments...])
, m_cells(cells), m_srfcs(srfcs)
{
[... some code ...]
}

Now my problem is that I have no clue what the comma-separated
arguments(?) m_cells and m_srfcs do in this method definition. Is
anyone able to enlighten me what this syntax is good for?

Besides not knowing what those arguments do, I must know wether this
usage of the two class instances (m_cells and m_srfcs are instances of
2 classes) would call their constructor, because in that case I would
need to modify the argument passed to them.

I would simply test this, but the project is just too big and there are
too many changes that I have to do at once before I can do a test
compilation and check it's runtime behaviour.

Any help is appreciated :)

Regards,

Lars Uffmann

[deane_gavin]

lars.uffm...@rw th-aachen.de wrote:

I have to work on a rather big project that a bunch of people wrote and
that has no useful documentation at all, my C++ has rusted in a bit,
now I stumbled over a constructor that looks something like the below
and have no idea what to do with it :)

inheritedClass: :inheritedClass ([...bunch of arguments...])
: originalConstru ctor ([...bunch of arguments...])
, m_cells(cells), m_srfcs(srfcs)
{
[... some code ...]
}

Now my problem is that I have no clue what the comma-separated
arguments(?) m_cells and m_srfcs do in this method definition. Is
anyone able to enlighten me what this syntax is good for?
http://www.parashift.com/c++-faq-lit....html#faq-10.6
Besides not knowing what those arguments do, I must know wether this
usage of the two class instances (m_cells and m_srfcs are instances of
2 classes) would call their constructor, because in that case I would
need to modify the argument passed to them.

Yes, that syntax calls the constructors for m_cells and m_srfcs

Gavin Deane

[Gabriel]

la**********@rw th-aachen.de wrote:

I have to work on a rather big project that a bunch of people wrote and
that has no useful documentation at all, my C++ has rusted in a bit,
I doubt that this is a good idea. You seem not to be qualified for this.
now I stumbled over a constructor that looks something like the below
and have no idea what to do with it :)

inheritedClass: :inheritedClass ([...bunch of arguments...])
: originalConstru ctor ([...bunch of arguments...])
, m_cells(cells), m_srfcs(srfcs)
{
[... some code ...]
}

Now my problem is that I have no clue what the comma-separated
arguments(?) m_cells and m_srfcs do in this method definition. Is
anyone able to enlighten me what this syntax is good for?
m_cells and m_srfcs are members variables of inheritedClass. The above
initializes theese varibles with the values 'cells' and 'srfcs'.

This is a very basic idiom. You should refer to your Stroustrup (chapter
10.4.6) or other textbook of your choice to read about it.
Besides not knowing what those arguments do, I must know wether this
usage of the two class instances (m_cells and m_srfcs are instances of
2 classes) would call their constructor, because in that case I would
need to modify the argument passed to them.

I would simply test this, but the project is just too big and there are
too many changes that I have to do at once before I can do a test
compilation and check it's runtime behaviour.
No need to change the project. Just create a very small sandbox project
with just one file to explore the syntax and behaviour of this idiom.

Gabriel
Any help is appreciated :)

Regards,

Lars Uffmann

[Gabriel]

la**********@rw th-aachen.de wrote:

Btw, I'm just curious: At which institute do you work?

Gabriel

I have to work on a rather big project that a bunch of people wrote and
that has no useful documentation at all, my C++ has rusted in a bit,
now I stumbled over a constructor that looks something like the below
and have no idea what to do with it :)

inheritedClass: :inheritedClass ([...bunch of arguments...])
: originalConstru ctor ([...bunch of arguments...])
, m_cells(cells), m_srfcs(srfcs)
{
[... some code ...]
}

Now my problem is that I have no clue what the comma-separated
arguments(?) m_cells and m_srfcs do in this method definition. Is
anyone able to enlighten me what this syntax is good for?

Besides not knowing what those arguments do, I must know wether this
usage of the two class instances (m_cells and m_srfcs are instances of
2 classes) would call their constructor, because in that case I would
need to modify the argument passed to them.

I would simply test this, but the project is just too big and there are
too many changes that I have to do at once before I can do a test
compilation and check it's runtime behaviour.

Any help is appreciated :)

Regards,

Lars Uffmann

[Sunil Varma]

la**********@rw th-aachen.de wrote:

I have to work on a rather big project that a bunch of people wrote and
that has no useful documentation at all, my C++ has rusted in a bit,
now I stumbled over a constructor that looks something like the below
and have no idea what to do with it :)

inheritedClass: :inheritedClass ([...bunch of arguments...])
: originalConstru ctor ([...bunch of arguments...])
, m_cells(cells), m_srfcs(srfcs)
{
[... some code ...]
}

Now my problem is that I have no clue what the comma-separated
arguments(?) m_cells and m_srfcs do in this method definition. Is
anyone able to enlighten me what this syntax is good for?

Besides not knowing what those arguments do, I must know wether this
usage of the two class instances (m_cells and m_srfcs are instances of
2 classes) would call their constructor, because in that case I would
need to modify the argument passed to them.

I would simply test this, but the project is just too big and there are
too many changes that I have to do at once before I can do a test
compilation and check it's runtime behaviour.

Any help is appreciated :)

Regards,

Lars Uffmann

the comma separated arguments m_cells and m_srcs are initialization
constructs for those variables of that class.

those constructs call the corresponding constructors depending on the
type of arguments.

[lars.uffmann]

> m_cells and m_srfcs are members variables of inheritedClass.

The above initializes theese varibles with the values 'cells' and 'srfcs'.
Thank you - I've had a chance to talk with my "boss" at the institute
in between and that is the information I was looking for, he said the
same :)

For a moment I was wondering why the initialization isn't done in the
inherited Constructor, but that is because then the properly
initialized member variables would NOT be available for the original
constructor to be handled. Either way, this option of initializing
member variables was completely new to me :)
No need to change the project. Just create a very small sandbox
project with just one file to explore the syntax and behaviour of
this idiom. TBH, I only started working with Linux again when I was assigned to
this project, and while I am quite comfortable with producing quality
C++ code, I am not so familiar with the gnu compiler and makefiles yet
:)
I'll have to experiment a bit before I get a test project running I
guess, just been to lazy to do that yet.
Btw, I'm just curious: At which institute do you work?

Institute of Aerodynamics - we're working on a numerical flow solver,
my job is to merge two versions that have been modified by different
people without the use of a CVS, and later to port the flow solver for
usage on a cluster system (simultaneous computing).
Regards,

Lars Uffmann

[lars.uffmann]

btw thank you for the parashift link, Gavin, that sort of covered all
questions I had left about the initialization list :)
Except that I am still not sure wether this calls the constructors of
m_cells and m_srfcs. Because the call m_cells(cells) just initializes
the class, and (cells) is not an argument for m_cells constructor, but
rather an object of the same type as m_cells.

Either way, my main question is answered - I do not need to modify the
code in this case at all :)

Regards,

Lars Uffmann

[Sunil Varma]

la**********@rw th-aachen.de wrote:

btw thank you for the parashift link, Gavin, that sort of covered all
questions I had left about the initialization list :)
Except that I am still not sure wether this calls the constructors of
m_cells and m_srfcs. Because the call m_cells(cells) just initializes
the class, and (cells) is not an argument for m_cells constructor, but
rather an object of the same type as m_cells.

Either way, my main question is answered - I do not need to modify the
code in this case at all :)

Regards,

Lars Uffmann

in such case it calls the copy constructor of the of the m_cells
objects' class.

[lars.uffmann]

Copy constructor is a default constructor that exists for each object
that you create? Basically doing a memory copy of (cells) and
positioning the object pointer m_cells on that memory?

Regards,

Lars Uffmann

[Gabriel]

la**********@rw th-aachen.de wrote:

Copy constructor is a default constructor that exists for each object .....each class that you create? Basically doing a memory copy of (cells) and
positioning the object pointer m_cells on that memory?

Regards,

Lars Uffmann

Yup, that's right. You should be careful with this one. if your class
contains any pointers or contains classes containing pointers or
(recurse this), you are about to crash, since the data is not copied
recursively. In theese cases you should either write the copy
constructor or explicitly deactive it.
You can use this idiom to make the copy constructor inaccesible:
class Blob{
private: Blob& Blob(const Blob&);
// other stuff
};

--
Who is General Failure and why is he reading my hard disk?