valgrind | SVN repository at svn : | Version Control System library

I'm new to C and still don't really know how to work with valgrind. I'm doing a project where i need to create a function that returns a line of text from a file descriptor each time it's called using just one static variable.

Repeated calls (e.g., using a loop) to your get_next_line() function should let you read the text file pointed to by the file descriptor, one line at a time.

I have come up with this but I can't find where the memory leak is:

This code is missing a constructor initializer list:

I'm trying to fix a problem in my code since several days but I'm still stuck on it. I want to insert a value in a tab through a realloc but I have a memory leak (or something else) and I don't know why.

Here's my code:

The following code compiles in both GNU gfortran and Intel ifort. But only the gfortran compiled version will run successfully.

My first question is that the object A(v) that added the the map, it should be deleted automatically when exit the scope?

My second question is what would happen to the object added into the map, when program exits? I believe when I do a_[name] = A(v);, a copy is stored to the map. Also, do I need to provide a copy constructor?

Many topics told us that use small object like lambda expression could avoid heap allocation when using std::function. But my study shows not that way.

This is my experiment code, very simple

Edited to include MWE (removing example-lite) and added details about compilation and Valgrind output.

I am using the mutable keyword to achieve the result of lazy evaluation and caching a result. This works fine for a single object, but doesn't seem to work as expected for a collection.

My case is more complex, but let's say I have a triangle class that can calculate the area of a triangle and cache the result. I use pointers in my case because the thing being lazily evaluated is a more complex class (it is actually another instance of the same class, but I'm trying to simplify this example).

I have another class that is essentially a collection of triangles. It has a way to calculate the total area of all the contained triangles.

Logically, tri::Area() is const -- and mesh::Area() is const. When implemented as above, Valgrind shows a memory leak (m_Area).

I believe since I am using a const_iterator, the call to tri::Area() is acting on a copy of the triangle. Area() is called on that copy, which does the new, calculates the area, and returns the result. At that point, the copy is lost and the memory is leaked.

In addition, I believe this means the area is not actually cached. The next time I call Area(), it leaks more memory and does the calculation again. Obviously, this is non-ideal.

One solution would be to make mesh::Area() non-const. This isn't great because it needs to be called from other const methods.

I think this might work (mark m_Triangles as mutable and use a regular iterator):

However, I don't love marking m_Triangles as mutable -- I'd prefer to keep the compiler's ability to protect the constiness of m_Triangles in other un-related methods. So, I'm tempted to use const_cast to localize the ugly to just the method that needs it. Something like this (mistakes likely):

Not sure how to implement with const_cast -- should I be casting m_Triangles or this? If I cast this, is m_Triangles visible (since it is private)?

Is there some other way that I'm missing?

The effect I want is to keep mesh::Area() marked const, but have calling it cause all the tris calculate and cache their m_Area. While we're at it -- no memory leaks and Valgrind is happy.

I've found plenty of examples of using mutable in an object -- but nothing about using that object in a collection from another object. Links to a blog post or tutorial article on this would be great.

Thanks for any help.

From this MWE, it looks like I was wrong about the point of the leak.

The code below is Valgrind-clean if the call to SplitIndx() is removed.

In addition, I added a simple test to confirm that the cached value is getting stored and updated in the container-stored objects.

It now appears that the call m_Triangles[indx] = t1; is where the leak occurs. How should I plug this leak?

I'm learn about std::allocator. I try to allocate but use deallocate incorrectly I saw that it didn't use size argument, I confuse about the method could you please explain for me ? Thanks.

1. testcase1 "test" : I didn't deallocate, valgrind detected (correct)
2. testcase2 "test_deallocate" : I deallocate with size(0) less than actual size (400),valgrind or -fsanitize=address can't detect leak
3. testcase3 "test_deallocate2": I deallocate with size(10000) greater than actual size (400) compiler didn't warning , g++ with -fsanitize=address also can't detect this.

I have two structs, Holder and Held. Holder holds a reference to Held. Held holds an i32: