C++Talk.NET

venki · Guest

Hi,
Given 2 possible ways of creating a class:
class NestedClass
{
char chunk_[1024];
};
class PtrMember
{
NestedClass* pmember_;
}

and
class ContainedMember
{
NestedClass member_;
}

is creating (and using very frequently) ContainedMember on the heap
__significantly__ more efficient that creating PtrMember (and
PtrMember::pmember_ separately) on the heap?

I could think of only 2 reasons why it could be more efficient: cost of
2 news and possible locality of reference? But are these significant
enuff to warrant changin legacy code to use the contained approach?

thanks!
-venki

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

kanze · Guest

venki wrote:

PPD · Guest

Wherever possible I would prefer the contained approach. For the
following reasons:

1. Yes, the second new is unwarranted. If the system has a costly
memory allocation algorithm then it may get a bad performace hit
(doubling the allocation times).

2. When member_ is contained the locality of reference is guaranteed.
When it is separately dynamically allocated - one part of
ContainedMember object would be on stack and the other would be on
heap. These are very different memory areas.

3. If NestedClass object is separately allocated, the second new might
throw. If it is contained, such a possiblity does not exist. The
solution is more robust.

4. Finally it takes less space too (pmember_ pointer is not needed).

In general, I would take the dynamically allocated nested member route
only if I potentially:

1. May not need to do use the member in a good number of cases.

2. The nested member may have some creation parameter (for example
array size) that I may not know when I create the ContainedMember.

Your context does not suggest to qualify for these factors. Hence, I
would prefer the second class design.

Also, note that the first design is in line with Sutter's PIMPL idiom
(Exceptional C++). However that idiom would not come in the rescue as
the interface / implementation isolation is context here.

PPD

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Earl Purple · Guest

kanze wrote: