C++ (STL): remove specific object from list

[Andre S. Veteran]

Hello,

I have learned that I can create a linked list of objects, like this:

list< MyClass* > = myList;

I also know that if it were a list of primitive types, such as a list<int>, I could remove a specific element by calling

remove(myList.begin(), myList.end(), 8);

which for instance would remove any element that is 8.

However let's say MyClass has an attribute name_. I have a list of objects of type MyClass, and I'd like to create a function that finds and removes the object that has that name.

Stub:

void remove(string &name) const

{

remove(myList.begin(), myList.end(), ???);

}

The thing is, if I supply the string &name as an argument to the remove algorithm, it will attempt to compare MyClass objects with strings, which doesn't make sense. What I'd like it to do is compare the name_ attribute of its MyClass objects with the string &name.

I thought of supplying a boolean function that would return element->name_ == name, but the function would need two arguments (list<MyClass*> element, string &name) and I don't think that would work.

As you see I'm stuck.

[Lant]

The way I have done this (which is probably wrong as I taught it to myself) is to use a std::map.

This way you would do something like:

 std::map< std::string name, MyClass* > MyList;
MyList["ClassName"] = PtrToClass;
MyList.erase( the name of the class (the std::name), in this case "ClassName" );

Even if this is wrong hopefully someone can show me how to do it right.

[Mike]

for a list:

std::list<MyClass*> MyList

a remove function could be like:

void remove(string &name) const
{
  std::list<MyClass*>::iterator iter;
  for (iter = MyList.begin(); iter != MyList.end(); iter++)
  {
	if ((*iter)->name_.equalis(name))
	{
	  MyList.erase(iter);
	  break;
	}
  }
}

[Eoin]

Lant's suggestion is probably the correct one if changing the container is practical which would depend on the particular circumstances.

dev's suggestion is probably the easier (and by no means wrong) if you have to stick with list<>.

The more STL solution would be to use one of the supplied algorithms, in this case remove_if would seem appropriate. The link shows some sample code which uses 'compose1' and 'bind2nd' to construct the 'predicate' function. This is also the STL way of doing things, i.e. you are reusing generic components instead of writing lots of special case code.

If all this 'predicate' stuff is a bit confusing try a different approach. Give your class an overloaded equality operator with another class of the same type which only compares their name_ attribute. Then pass a dummy instance of such a class to remove with the name_ attribute set to the desired value to remove.

As you can gather there are really a load of approaches and this can make C++ seem overwhelming at first. Just remember no one way is necessarily the best. But usually the professionals prefer the solution which reuses existing generic code rather than the individual approach.

[Andre S. Veteran]

Ok I'm starting to make some sense of out bind2nd and compose1. Really cool stuff.

Another important question I have about the STL: let's say I have a vector of pointers to dynamic objects, for example:

std::vector< MyClass* > myVector;

MyClass * object1 = new MyClass();

MyClass * object2 = new MyClass();

myVector.push_back(object1);

myVector.push_back(object2);

When I call myVector.clear(), the cplusplus reference says that it will call the destructors for each of the elements. The thing is, I'm not sure if I need to call delete for each of these pointers or not.

[Mike]

dev's suggestion is probably the easier (and by no means wrong) if you have to stick with list<>.

i tend to go for more verbose code due to me favouring the C way of doing things over C++. Only times i use C++ parts is when i want a list of things and don't want to make my own linked list, or i need classes with subclasses. Most of the time i avoid the STL due it not liking threading very well (in my experience anyway)

Ok I'm starting to make some sense of out bind2nd and compose1. Really cool stuff.

Another important question I have about the STL: let's say I have a vector of pointers to dynamic objects, for example:

std::vector< MyClass* > myVector;

MyClass * object1 = new MyClass();

MyClass * object2 = new MyClass();

myVector.push_back(object1);

myVector.push_back(object2);

When I call myVector.clear(), the cplusplus reference says that it will call the destructors for each of the elements. The thing is, I'm not sure if I need to call delete for each of these pointers or not.

afaik you will need to delete the objects, i wasn't aware that calling clear() would call the destructors of the objects but apparently it does (Y)

[Eoin]

When I call myVector.clear(), the cplusplus reference says that it will call the destructors for each of the elements. The thing is, I'm not sure if I need to call delete for each of these pointers or not.

Yeah I think you still need to call delete. I'm pretty sure the destructors only get called for objects stored by value

std::vector< MyClass > myVector;

MyClass object1;

myVector.push_back(object1);

If you need to store them as pointers consider using a smart point like boost::shared_ptr<>.

[Andre S. Veteran]

Hm I'm really puzzled at how I am supposed to deallocate memory when erasing specific elements from a list. I thought about using auto_ptr (I can't use boost now), but the cplusplus reference advises against this:

Warning: It is generally a bad idea to put auto_ptr objects inside C++ STL containers. C++ containers can do funny things with the data inside them, including frequent reallocation (when being copied, for instance). Since calling the destructor of an auto_ptr object will free up the memory associated with that object, any C++ container reallocation will cause any auto_ptr objects to become invalid.

http://www.cppreference.com/cppmisc/auto_ptr.html

So what should I do?

[Eoin]

Well you can still manually call delete whenever you remove a element from a container, but ideally you do want a smart pointer to do this automatically.

If Boost IS an option then use shared_ptr as I suggested or the pointer containers. Or if you have access to tr1 the tr1::shared_ptr is the boost::shared_ptr basicially.

Otherwise you could try finding another reference counted smart pointer. The problem is inside STL containers objects can get copied as the container grows so if you used auto_ptr then at times there could exist two auto_ptr's to the same object. You need to use a reference counted smart pointer in this case as it ensures the object is deleted only when there are no smart pointers left pointing to it.

I know Scott Meyers published a reference counted smart pointer. Haven't used it myself but I imagine it should work fine. Of course it's published in one of his books but maybe you can find a listing of the code if you look around his online articles. His site maintains a list.

Others surely exist out there too but ideally you should use the boost or tr1 shared_ptr if you can.

[Andre S. Veteran]

Well, as I really have to stick to absolute basic stuff, the STL, and not use any sort of loops, I have developped a very heavy and unelegant solution. Basically I selectively copy the elements that must not be removed into a new container. But as the containers contain pointers to these elements, I have to really copy objects, a costly process. Then I call delete on every pointer of the old container, erase the container, and assign the new container to the old container. Then the new container is discarded.

[Eoin]

Well if you have to stick to very basic stuff then I assume what matters in the end is correctness over efficiency so I wouldn't worry about costs too much. Save optimisation for when you have fuller access to C++libraries.