There are some operations like sort, remove, remove_if which are
available as list<T> member functions; but vector<T>, deque<T> do not
seem have those functions. If am correct in this, what is the reason
for that. Moreover sort, remove, remove_if are available in
<algorithm> also. Then why does list<T> have these member operations ?

Kindly clarify.

Thanks
V.Subramanian

On 6 Feb, 09:30, "subramanian10...@yahoo.com, India"
<subramanian10...@yahoo.com> wrote:
> There are some operations like sort, remove, remove_if which are
> available as list<T> member functions; but vector<T>, deque<T> do not
> seem have those functions. If am correct in this, what is the reason
> for that. Moreover sort, remove, remove_if are available in
> <algorithm> also. Then why does list<T> have these member operations ?
>

The algorithms in <algorithm> operate on ranges, not containers.
Therefore, an algorithm like std::remove_if will not actually remove
any elements, just copy the elements not removed to the front of the
range, and return a new end iterator.

The member functions of list naturally operate on the list itself.
Therefore list<T>::remove and list<T>::remove_if will actually erase
the elements from the list.

In general using the member functions where present will be faster,
and they often do slightly different things.

As for std::sort, this algorithm requires random access iterators,
while list only has bidirectional iterators. Therefore it needs its
own sort function.

Triple-DES wrote:
> On 6 Feb, 09:30, "subramanian10...@yahoo.com, India"
> <subramanian10...@yahoo.com> wrote:
>> There are some operations like sort, remove, remove_if which are
>> available as list<T> member functions; but vector<T>, deque<T> do not
>> seem have those functions. If am correct in this, what is the reason
>> for that. Moreover sort, remove, remove_if are available in
>> <algorithm> also. Then why does list<T> have these member operations ?

> As for std::sort, this algorithm requires random access iterators,
> while list only has bidirectional iterators. Therefore it needs its
> own sort function.

Does anyone know why this is not done with a specialisation of the sort
algorithm?

The same applies to find, i.e.

map m;
vector v;

m.find(...); // O(log N)
find(v.begin(),v.end(),...); // O(N)
find(m.begin(),m.end(),...); // O(N)
// but could be O(log N) if specialised?


Phil.

On 6 Feb, 12:23, Phil Endecott <spam_from_usenet_0...@chezphil.org>
wrote:
> Triple-DES wrote:
> > On 6 Feb, 09:30, "subramanian10...@yahoo.com, India"
> > <subramanian10...@yahoo.com> wrote:
> >> There are some operations like sort, remove, remove_if which are
> >> available as list<T> member functions; but vector<T>, deque<T> do not
> >> seem have those functions. If am correct in this, what is the reason
> >> for that. Moreover sort, remove, remove_if are available in
> >> <algorithm> also. Then why does list<T> have these member operations ?
> > As for std::sort, this algorithm requires random access iterators,
> > while list only has bidirectional iterators. Therefore it needs its
> > own sort function.
>
> Does anyone know why this is not done with a specialisation of the sort
> algorithm?

It may not be impossible to do it, but I for one can't think of a good
way to implement it. The naive approach

template<typename T>
void sort(typename std::list<T>::iterator first, typename
std::list<T>::iterator last)

doesn't work because the nested type can not be deduced (14.8.2.4/4).
Obtaining the actual container from just the two iterators could also
be a problem.

On Feb 6, 12:23 pm, Phil Endecott <spam_from_usenet_0...@chezphil.org>
wrote:
> Triple-DES wrote:
> > On 6 Feb, 09:30, "subramanian10...@yahoo.com, India"
> > <subramanian10...@yahoo.com> wrote:
> >> There are some operations like sort, remove, remove_if which are
> >> available as list<T> member functions; but vector<T>, deque<T> do not
> >> seem have those functions. If am correct in this, what is the reason
> >> for that. Moreover sort, remove, remove_if are available in
> >> <algorithm> also. Then why does list<T> have these member operations ?
> > As for std::sort, this algorithm requires random access iterators,
> > while list only has bidirectional iterators. Therefore it needs its
> > own sort function.

> Does anyone know why this is not done with a specialisation of
> the sort algorithm?

Because the algorithms don't take containers, only iterators.
Once you've only got begin and end, you're stuck; you can't get
back to the container. (Note too that the iterators I pass to
std::sort may not cover the entire container.)

> The same applies to find, i.e.

> map m;
> vector v;

> m.find(...); // O(log N)
> find(v.begin(),v.end(),...); // O(N)
> find(m.begin(),m.end(),...); // O(N)
> // but could be O(log N) if specialised?

Same problem.

--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34