Sorting a QVector

[marcel]

operator=() should never be used for a swap operation. Why use deep copies if, after the function call, you still end up with exactly the same dynamic data? A shallow copy only moves the pointers around (and the primitive types). For the swap function this should be enough. And I'd be surprised if the standard C++ implementation did it differently.

But it will use the =() operator if the type T provides it(qSwap is a template function).
Otherwise it is just a memcpy over the destination.

[Michiel]

But it will use the =() operator if the type T provides it(qSwap is a template function).
Otherwise it is just a memcpy over the destination.

Exactly. And it should just be a memcpy. When would you want a swap function to use operator=()?

[wysota]

When you can't memcpy objects. And you can't memcpy most complex objects... As far as I understand the compiler will only "memcpy" PODs.

http://doc.trolltech.com/latest/qtgl...CLARE_TYPEINFO
http://doc.trolltech.com/qq/qq19-containers.html (take a look at the paragraph mentioning Q_DECLARE_TYPEINFO)

And answering your question about wanting to use an assignment operator for swapping - for instance when you have a class that is to be used in multithreaded environment. Swaping using memcpy() and modifying the object from within another thread at the same time will break it completely. You have to use operator=() there to be certain you're blocking access with mutexes.

[Michiel]

And answering your question about wanting to use an assignment operator for swapping - for instance when you have a class that is to be used in multithreaded environment. Swaping using memcpy() and modifying the object from within another thread at the same time will break it completely. You have to use operator=() there to be certain you're blocking access with mutexes.

Hm. Yes, I suppose that's true. However, if that is the only reason, deep copies are still being made when they don't have to. You could have a list with 100.000 values that must be copied twice in the name of thread safety.

If there is another way to isolate the swap operation, things could be much more efficient.

[marcel]

If there is another way to isolate the swap operation, things could be much more efficient.

If you are sure it is doable you can always implement your own using memcpy.

And answering your question about wanting to use an assignment operator for swapping - for instance when you have a class that is to be used in multithreaded environment. Swaping using memcpy() and modifying the object from within another thread at the same time will break it completely. You have to use operator=() there to be certain you're blocking access with mutexes.

How is qSwap thread safe?
You still have to put a lock on the mem locations you want to swap even with qSwap.
I don't mean about Qt classes that are already thread-safe, but a user class.
Would one trade performance over implementing locking in the operator=() and not in some other place?

[wysota]

Actually qSwap doesn't use memcpy directly (4.3 beta):

template <typename T>
inline void qSwap(T &value1, T &value2)
{
    if (!QTypeInfo<T>::isComplex || QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        T t = value1;
        value1 = value2;
        value2 = t;
    } else {
        const void * const t = reinterpret_cast<const void * const &>(value1);
        const_cast<const void *&>(reinterpret_cast<const void * const &>(value1)) =
            reinterpret_cast<const void * const &>(value2);
        const_cast<const void *&>(reinterpret_cast<const void * const &>(value2)) = t;
    }
}

template <typename T>
inline void qSwap(T &value1, T &value2)
{
    if (!QTypeInfo<T>::isComplex || QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
        T t = value1;
        value1 = value2;
        value2 = t;
    } else {
        const void * const t = reinterpret_cast<const void * const &>(value1);
        const_cast<const void *&>(reinterpret_cast<const void * const &>(value1)) =
            reinterpret_cast<const void * const &>(value2);
        const_cast<const void *&>(reinterpret_cast<const void * const &>(value2)) = t;
    }
}

To copy to clipboard, switch view to plain text mode 

I admit I don't understand those spells with casting, but they look smart

It's not that qSwap is thread safe, it's that you can use such classes with it. You have to care about locking your class on your own. It's a general assumption about using operator=(), not about swapping items.

Anyway we're highly offtopic here It doesn't really matter if you use qSwap or swap for sorting QVector.

[marcel]

Actually qSwap doesn't use memcpy directly (4.3 beta):

Weird enough. It must have remained a beta .
I can't really find this implementation anywhere in 4.3.0 ( not beta ).

I even made small test and stepped in qSwap. The one I posted above is used for all types.

EDIT:
I think those casts only switch the base addresses of the variables without actually swapping any memory or calling =() operators.

Regards

[arjunasd]

Hi all

I am trying to sort a QList. I am using a custom type with overloaded < operator but then to check out the source of error, I changed the list to a interger one.

My code now is just this:

QList<int> list;
list << 10 << 5 << 4;
qsort(list.begin(), list.end());

I am getting the following error.

Cannot convert QList<int>::iterator to void* argument for '1' to 'void qsort(void* ,size_t, size_t, int (*) (const void*, const void*))'

Can anyone suggest what would be the possible error?

[marcel]

It is qSort, with capital "S".

Or, if not, try:

qSort(list.begin(), list.end(), qLess<int>());

qSort(list.begin(), list.end(), qLess<int>());

To copy to clipboard, switch view to plain text mode 

Regards

[wysota]

You can also simply call "qSort(list)" if you want to sort the whole list.

[marcel]

I can't imagine a reason right now.
However, even structure assignment is implemented in the language as member by member assignment.

So, in wysota's example above, no memcpy will occur(although it would work), but the two QString members will be assigned one by one, causing QString:perator=() to intervene.

Regards