Re: Should I use pointer inside container?
On Sep 15, 9:04 pm, werasm <wer...@gmail.com> wrote:
terminator wrote:
[...]
also pointers can simply point to some stack variable in the present
thread as well.
Of course
The contribution? Very obvious!!! Copying containers is generally both
memory and runtime consuming and should be avoided whenever
possible ,and the simplest way is to use ref/ptr semantics.
In my opinion (and IME) copying is quite a rare occurrence, especially
copying of objects with containers as members.
It depends. Some frequently copied value types could involve
containers: a Position3D class might contain a vector, for
example. Typically, though, you probably won't have to copy
objects with large containers very often, in which case, it
might not affect your runtime that much anyway, and of course,
it's really a question of semantics: if you want or need a copy
of the container, you copy; if identity is important (usually
the case with large containers), you don't.
You are compromising
maintainability for efficiency which in most cases give you no gain.
I Agreed that if it did matter, wrap it in a smart pointer (as
you want to copy, it would probably be a shared pointer). The
question remains: Would you want the copy to be bounded to the
original, or not
Exactly. It's a question of value semantics vs. identity, not
performance. Copying an object and copying a pointer have very
different semantics, and it's hard to imagine a case where you
can replace one with the other. (There are a few exceptions;
e.g. as an out argument of a function. In such cases, *if* the
copy turns out to be a bottleneck, you might have to look for a
different solution---in this specific case, for example, by
having the client declare the container, and pass a non-const
reference to it.)
- if not, there is no purpose in storing a pointer. I could
give you an elaborate example, but I hope you understand my
point.
More generally, dynamic allocation should only be used when
necessary. Off hand, only a few cases come to mind: arbitrary
object lifetime and dynamically sized objects; in some cases,
polymorphic objects may require dynamic allocation as well.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34