• 0

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


Question

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.

10 answers to this question

Recommended Posts

  • 0

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&lt; std::string name, MyClass* &gt; 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.

  • 0

for a list:

std::list&lt;MyClass*&gt; MyList

a remove function could be like:

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

  • 0

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.

  • 0

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.

  • 0
  Eoin said:
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)

  Dr_Asik said:
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)

  • 0
  Dr_Asik said:
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<>.

  • 0

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?

  • 0

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.

  • 0

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.

This topic is now closed to further replies.
  • Recently Browsing   0 members

    • No registered users viewing this page.
  • Posts

    • Microsoft is removing legacy drivers from Windows Update by Usama Jawad Last month, we learned that Microsoft is making major changes to the development of hardware drivers in Windows. This included the retirement of Windows Metadata and Internet Services (WMIS), along with the process for pre-production driver signing. Now, the Redmond tech firm has informed partners that it will be getting rid of old drivers in Windows Update. In what is being described as a "strategic" move to improve the security posture and compatibility of Windows, Microsoft has announced that it will be performing a cleanup of legacy drivers that are still being delivered through Windows Update. Right now, the first phase only targets drivers that already have modern replacements present in Windows Update. As a part of its cleanup process, Microsoft will expire legacy drivers so that it is not offered to any system. This expiration involves removing audience segments in the Hardware Development Center. Partners can still republish a driver that was deemed as legacy by Microsoft, but the firm may require a justification. Once the Redmond tech giant completes its first phase of this cleanup, it will give partners a six-month grace period to share any concerns. However, if no concerns are brought forward, the drivers will be permanently eradicated from Windows Update. Microsoft has emphasized that this will be a regular activity moving forward and while the current phase only targets legacy drivers with newer replacements, the next phases may expand the scope of this cleanup and remove other drivers too. That said, each time the company takes a step in this direction, it will inform partners so that there is transparency between both parties. Microsoft believes that this move will help improve the security posture of Windows and ensure that an optimized set of drivers is offered to end-users. The firm has asked partners to review their drivers in Hardware Program so that there are no unexpected surprises during this cleanup process.
    • No idea, but I had a client the other week that lost the entire drive to it. I suggested relying on the Samsung T7's instead. The Sandisk Extreme's had reliability issues too.
    • I use it every day so personally yes I need it, or rather I want it. I use OpenShell though, not the garbage modern Start Menu. I just counted and at the moment I have a total of 92 program shortcuts organized into six folders almost exactly the way I did back in Windows 95. I can get to any program I want to run very quickly. I never use Search to find or run programs.
    • I do miss the Apps view from Windows 8.1 Update.
    • I use the search function and little else since Windows 11 (but there are times where Saved Searches take precedence since the search feature on the Start menu is worse than before). I use other features in previous releases.
  • Recent Achievements

    • Collaborator
      lethalman went up a rank
      Collaborator
    • Week One Done
      Wayne Robinson earned a badge
      Week One Done
    • One Month Later
      Karan Khanna earned a badge
      One Month Later
    • Week One Done
      Karan Khanna earned a badge
      Week One Done
    • First Post
      MikeK13 earned a badge
      First Post
  • Popular Contributors

    1. 1
      +primortal
      664
    2. 2
      ATLien_0
      262
    3. 3
      Michael Scrip
      212
    4. 4
      +FloatingFatMan
      168
    5. 5
      Steven P.
      156
  • Tell a friend

    Love Neowin? Tell a friend!