Re: stl <vector> clear and erase.
On May 1, 3:33 pm, Daniel Kr?gler <daniel.krueg...@googlemail.com>
wrote:
In theory, a compiler could deduce that the initial 0 value for a
statically sized vector of int is never read in the program, and so
elide the initialization, in the same way that it could elide the
obviously no-op pseudo-destructor. I agree that that would be
harder for the compiler to deduce reliably though.
In theory, yes, but I haven't seen this happening in real life. It
would require a much more kind of non-local code analysis, while the
above mentioned pseudo-destructor elimination can easily be done by
means of portable library code.
Compilers (well, gcc, and I assume the other popular ones) are now
getting very good at this sort of thing, for stack allocated data.
In fact, gcc knows about malloc() and free(), and the following
program:
#include <cstdlib>
using namespace std;
int main()
{
int* a = (int*)malloc(10);
for(int i=0; i < 16; i++)
a[i]=7;
free(a);
}
never bothers to initialise the memory before deleting it.
It doesn't yet remove calls to malloc and free, however.
Also, g++ doesn't seem to be able to apply the same knowledge to new[]
and delete[] yet.
The usual technique is to evaluate
some trait, like is_trivially_destructible (or corresponding compiler
intrinsics that did already exist in C++03) and to make a compile-time
code branch here. There is no much magic involved and therefore this
technique is very popular.
I'm not sure there's any need for that any more. The compiler seems to
be good at doing this kind of thing itself.
-Ed
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]