gamedevlists-windows

RV: [GD-Windows] memory leak?

[Diego D. <br...@te...>]

I don't think so, the only diference between struct and class is the
default access level -- private in classes, public in structs. As Ivan
said, don't expect a std::vector to be decreasing its capacity, the
standard only requires the erase methods to call destructors and
invalidate the items in the array. This is what it says:

 iterator erase(iterator position);
  iterator erase(iterator first, iterator last);

  Effects:
    Invalidates all the iterators and references after the point of  the
    erase.
  Complexity:
    The  destructor of T is called the number of times equal to the num-
    ber of the elements erased, but the  assignment  operator  of  T  is
    called  the  number  of times equal to the number of elements in the
    vector after the erased elements.

In fact, if std::vector reallocated the data on erase, it wont meet the
complexity requeriments set by the standard. Check other containers in
the STL if you really need that.



> De: gam...@li...
> [mailto:gam...@li...] En 
> nombre de Colin Fahey
> Enviado el: Thursday, November 07, 2002 2:05 PM
> Para: GDWindows
> Asunto: Re: [GD-Windows] memory leak?

[..]
> [A] Best guess:  You are doing "new" and "delete"
> on a regular "struct", instead of a "class".
> This may simply allocate raw bytes with the
> same size as your structure.  This means that
> the "std::vector<float> array" member is NOT
> CONSTRUCTED, but is simply given space to exist.
> Even though C++ compilers may implement
> "struct" as "class", I don't know if "new" will
> CONSTRUCT members of a "struct".
> Anyhow, I'm guessing that the "delete" calls
> aren't calling the destructor of the "array"
> object within the "struct" (TestObj).

[..]


Diego

Re: [GD-Windows] memory leak?

[Colin F. <cp...@ea...>]

2002 November 7th
Thursday

Okay, I just wasn't sure if "new" and "delete" on a
"struct" would, in practice, work the same way as
with a "class".  Let's just say I avoid pointless risks,
and I'd use "class" instead of "struct" if the 
object in question had member variables that
required construction.

The code sample with the "memory leak" calls
std::vector::clear() -- not "erase()".
Sure, capacity is never reduced by "erase()",
but "clear()" (with VC++ .NET implementation)
makes the same single "_Tidy()" call as the
destructor -- which allegedly really does
free memory after calling the destructor on
all elements.

In any case, I don't see how (assuming Jason's
STL implementation isn't broken) STL has
anything to do with the "memory leak",
since Jason's code is doing "new" and 
"delete" on objects that happen to CONTAIN
an STL container.  It's not about capacity
of vectors never shrinking; the whole vector
should be destroyed!

So, I'm still vaguely suspicious about the
vector destructor actually being called when
Jason does the delete on a TestObj -- but I
am totally willing to believe that "struct"
and "class" are essentially treated the
same by the compiler (apart from the very
minor default "public" vs "private"
distinctions).

Maybe it's worthwhile to examine the other
two possibilities I proposed:
[B] Process memory grows due to reading in
  more code (DLL or EXE) because new 
  code/functions were called;
[C] Lazy C runtime library is hanging on to
  memory after all allocations are freed
  just because it is likely you'll want
  more memory again in the near future
  -- and maybe it can avoid expensive
  system calls.

But perhaps the real issue is the method
of measurement of "process (memory) consumption",
and the interpretation of that quantity.

--- Colin
cp...@ea...