What is better std::list or CList?

std::list is superior for many reasons.

a) It's standard C++.

b) It's not MFC specific. CList can only be used in MFC applications. The std::list can be used in any application -- MFC, non-MFC, console, Windows, Unix, etc. Why? see item a)

c) It is more powerful than CList.

However, I don't understand what a GUI component (the Tree Control) has to do with using std::list over CList. Maybe you should explain this in more detail.

Regards,

Paul McKenzie

Sorry, I didn't mention it. My program is actually an MFC Dlg application. And I start handling my objets in a std::list. But I feel like I have had to write a lot of code to do something. Sometimes I think it would be better to switch to CList.

Thanks for your quick response.:D :D :D

Originally posted by Philip Nicoletti
Also std::list has a sort() member function. I don't
think the CList does.

Are you sure that sort() is a member of std::list?

Yes, sort() is part of std::list and I know CList does not have a sort function but it does have the option to insert items in the position I want, this will supply my need of using sort().

I am using three clases Item->SubMenu->Menu. Each type of object is contain by its sucessor in a list. Lets say Menu contains a list of SubMenus, an this one a list of items. There is also a Main Menu List.

I overwrite the sort funtion in Item since it is the basic class this is the code. I personalize my search based on an specific value contained in the object.

bool operator<(const CItem &item2) const {return iPosition < item2.iPosition;}

Then I have my CTreeCtrl implemented class where I called sort, but it looks like it never get called. Inside my Drag and Drop code I insert the new item dropped based on the parent type to be insert on.

if(pMainMenu == NULL)
cMenus->push_front( (CMainMenu*)pItem );
else if(pMainMenu->IsKindOf(RUNTIME_CLASS(CMainMenu)))
pMainMenu->MainMenuList->push_front((CSubMenu*)pItem);
else if(pMainMenu->IsKindOf(RUNTIME_CLASS(CSubMenu)))
pMainMenu->ItemsList->push_front(pItem);

After the insertion I called sort based on my object values. MainMenuList and ItemsList are the lists part of the object that contain SubMenus and Items respectivelly.

if(pMainMenu->IsKindOf(RUNTIME_CLASS(CMainMenu)))
pMainMenu->MainMenuList->sort();
else if(pMainMenu->IsKindOf(RUNTIME_CLASS(CSubMenu)))
pMainMenu->ItemsList->sort();

It never sorts my items... Am I doing really crazy things?. Thank you for your help again.

pMainMenu->ItemsList->sort();

This is your culprit. Since your list is a list of pointers, it is merely sorting the pointers.

You can use a predicate to fix this, as follows:

template<typename T>
struct deref_greater : public std::greater<T>
{
bool operator()(T l, T r)
{
return *l > *r;
}
};

...
pMainMenu->ItemsList->sort(deref_greater<CItem*>());

Edit: Added '()' for deref_greater construction.

Jeff

Originally posted by ayana
Yes, sort() is part of std::list and I know CList does not have a sort function but it does have the option to insert items in the position I want, this will supply my need of using sort().
So does std::list. The std::list::insert() function is available. You need to use advance to get to the position where you want to insert. What is usually done is to get an iterator to the first item, and advance to where you want to insert the item

#include <list>
#include <algorithm>
std::list<int> IList;
//...
// Insert a 17 after position 2
std::list<int>::iterator it = IList.begin();
std::advance(it, 2);
IList.insert(it, 178);

I personalize my search based on an specific value contained in the object.
OK so far.
bool operator<(const CItem &item2) const {return iPosition < item2.iPosition;}

if(pMainMenu == NULL)
cMenus->push_front( (CMainMenu*)pItem );
else if(pMainMenu->IsKindOf(RUNTIME_CLASS(CMainMenu)))
pMainMenu->MainMenuList->push_front((CSubMenu*)pItem);
else if(pMainMenu->IsKindOf(RUNTIME_CLASS(CSubMenu)))
pMainMenu->ItemsList->push_front(pItem);
Your operator < is not being called. You need to use the predicate version of the sort function.

This code should work:

template <>
struct std::greater<CItem*>
{
bool operator()(const CItem* lhs, const CItem* rhs) const
{
return lhs->iPosition < rhs->iPosition;
}
};

//...

pMainMenu->ItemsList->sort(std::greater<CItem*>());

The reason for the std::greater<> is that the VC++ version of std::list is broken, plain and simple. If it were not broken, all you would need is to specify a functor or function pointer for the predicate function. Hopefully this gets around the problem.

Here is a small sample program that maybe easier to understand:

#include <list>
#include <iostream>

struct foo
{
int nValue;
foo(int n=0) : nValue(n){ }
};

typedef std::list<foo *> pFooList;

template <>
struct std::greater<foo*>
{
bool operator()(const foo* lhs, const foo* rhs) const
{
return lhs->nValue < rhs->nValue;
}
};

using namespace std;

int main()
{
pFooList FL;
pFooList::iterator it;

FL.push_back(new foo(1));
FL.push_back(new foo(3));
FL.push_back(new foo(2));

it = FL.begin();
while ( it != FL.end())
{
cout << (*it)->nValue << endl;
++it;
}
cout << endl;
FL.sort(std::greater<foo*>());
it = FL.begin();
while ( it != FL.end())
{
cout << (*it)->nValue << endl;
++it;
}
cout << endl;

}

Forget about the memory leak in the sample above. I only posted this to illustrate how list::sort would work for something similar to what you are doing.

Regards,

Paul McKenzie

Thank you Paul McKenzie. I will try this which is very understandable for me....:D

Graham,
No, I have not use "find" in the TreeCtrl, is anything that can help me from there?

This example provieded by Paul McKenzie works fine with VC but fails in a Sun compiler:

Error: Could not find a match for std::list<foo*, std::allocator<foo*>>::sort(std::greater<foo *>).

Does someone has any hints?

Thanks,
Herminio

Thanks a lot.

Herminio

I just found out why list has a sort. std::sort requires a random access iterator, which list does not have.

You would probably be better off using std::vector instead of std::list. Sorting as well as most other things will be faster.

Rule of thumb: default to vector as your container of choice and if it doesn't quite fit what you need, then look to the other containers.

JeffHi All,

Some comments:
1. As far as I know, std::vector does not have a sort method.

2. The reason because foo wasn't working in the Sun Studio is because you have to use another library: -library=stlport4

Thanks for your help and comments.

Herminio

Not sure what you mean by std::sort() being even more efficient. list::sort() has the advantage that it doesn't require the contents of the list to be copied - the whole sort can be done by reassigning pointers, so it's not obvious that one will be more efficient than the other. Anyway, you should pick the container you use based on your needs, not on "default" positions or perceived efficiency in a single area.

That is because it is only supposed to be the workaround for the Visual C++ bug.

Hi Paul,

Is it okay to specify a predicate-function pointer in a VC-based STL implementation, or am I bound to public std::greater <MyClass> which to my personal tastes looks ugly!

Thanks,
Sid