Re: How can you quickly find the number of elements stored in a a)
static array b) dynamic array ?
On Jan 12, 7:24 pm, jkherci...@gmx.net wrote:
James Kanze wrote:
On Jan 12, 3:27 pm, jkherci...@gmx.net wrote:
C C++ C++ wrote:
[...]
For an array of T dynamically allocated with new[] and stored
in a variable of type T*, you are simply out of luck:
But is there ever, ever a use for such a thing. I've been
programming in C++ for over 15 years now, and I've never used
array new.
I did: many of my classes are container-like. Ok, strictly
speaking, I also never new[] an array since the classes are
all templated on an allocator.
Exactly. Even 15 years ago, before I'd ever heard of
allocators, and was still simulating templates with <generic.h>,
I never used a raw dynamically allocated [], and all of my
containers separated allocation and construction, so that I
could pre-allocate (like std::vector). Which meant that they
used the ::operator new() function, rather than new[]. (There
was no ::operator new[]() function at the time. But even today,
the default allocator in the standard uses the ::operator new()
function, and not ::operator new[]().)
although the compiler has to keep track of the array size (at
least if T has a non-trivial destructor and there is a
corresponding delete[]), there is no way in standard C++ to
get at that piece of information. Thus, you need to store the
length manually. If T is copy-constructible and assignable,
you should of course use std::vector instead. That will keep
track of the size for you.
And if T isn't copy-constructible and assignable, you're stuck
with an array with all of the elements initialized with the
default constructor, and no way to change the value, if you use
new[]. That doesn't sound very useful either.
Well, it could be a type that implements only one of the two
concepts. (Not that I know why one would do that:-)
There's always the possibility that the default constructor
accesses some static variable, and updates it. But that's
something I definitly wouldn't recommend.
In the end, using container classes is the only way to go. And
said container classes should use the solution adopted by
std::vector---which was estabilished "best practice" long before
the STL was invented. (On the other hand, the work on the STL
provided the impetus for member templates, and member templates
definitely make the solution more agreeable.)
--
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