Question about qvector.h code of Qt 4

[karapas]

Hi all!
While I was looking at the code of qvector.h (the header file of QVector class - I use Qt 4.2.2) and I noticed something which I don't understand. For example, here is the implementation of the QVector:append() method:

template <typename T>
void QVector<T>::append(const T &t)
{
    const T copy(t);
    if (d->ref != 1 || d->size + 1 > d->alloc)
        realloc(d->size, QVectorData::grow(sizeof(Data), d->size + 1, sizeof(T),
                                           QTypeInfo<T>::isStatic));
    if (QTypeInfo<T>::isComplex)
        new (d->array + d->size) T(copy);
    else
        d->array[d->size] = copy;
    ++d->size;
}

template <typename T>
void QVector<T>::append(const T &t)
{
    const T copy(t);
    if (d->ref != 1 || d->size + 1 > d->alloc)
        realloc(d->size, QVectorData::grow(sizeof(Data), d->size + 1, sizeof(T),
                                           QTypeInfo<T>::isStatic));
    if (QTypeInfo<T>::isComplex)
        new (d->array + d->size) T(copy);
    else
        d->array[d->size] = copy;
    ++d->size;
}

To copy to clipboard, switch view to plain text mode 

So my question is:
What's the use of the copy variable? Is it there for a reason or is it redundant?

Would the following code:

template <typename T>
void QVector<T>::append(const T &t)
{
   // const T copy(t);
    if (d->ref != 1 || d->size + 1 > d->alloc)
        realloc(d->size, QVectorData::grow(sizeof(Data), d->size + 1, sizeof(T),
                                           QTypeInfo<T>::isStatic));
    if (QTypeInfo<T>::isComplex)
        new (d->array + d->size) T(t);
    else
        d->array[d->size] = t;
    ++d->size;
}

template <typename T>
void QVector<T>::append(const T &t)
{
   // const T copy(t);
    if (d->ref != 1 || d->size + 1 > d->alloc)
        realloc(d->size, QVectorData::grow(sizeof(Data), d->size + 1, sizeof(T),
                                           QTypeInfo<T>::isStatic));
    if (QTypeInfo<T>::isComplex)
        new (d->array + d->size) T(t);
    else
        d->array[d->size] = t;
    ++d->size;
}

To copy to clipboard, switch view to plain text mode 

do the same thing as the original code?

The same practice seems to be used in other functions of QVector as well like in QVector::fill():

template <typename T>
QVector<T> &QVector<T>::fill(const T &from, int asize)
{
    const T copy(from); //is it really needed???
    resize(asize < 0 ? d->size : asize);
    if (d->size) {
        T *i = d->array + d->size;
        T *b = d->array;
        while (i != b)
            *--i = copy;
    }
    return *this;
}

template <typename T>
QVector<T> &QVector<T>::fill(const T &from, int asize)
{
    const T copy(from); //is it really needed???
    resize(asize < 0 ? d->size : asize);
    if (d->size) {
        T *i = d->array + d->size;
        T *b = d->array;
        while (i != b)
            *--i = copy;
    }
    return *this;
}

To copy to clipboard, switch view to plain text mode 

and probably in other classes too.

So, is this practice of creating a const copy (as an automatic variable) redundant or am I missing something???

[jacek]

Consider such code:

QVector<int> v;
...
v.append( v[0] );

QVector<int> v;
...
v.append( v[0] );

To copy to clipboard, switch view to plain text mode 

What will happen if realloc() moves the data?

[Michiel]

So why pass t by reference in the first place then?

[jacek]

So why pass t by reference in the first place then?

Who knows? Maybe this problem was noticed after the interface was set or maybe to leave a possibility for more efficient implementation in future or for some other reason. You will have to ask the Trolls.

Anyway now it's just like if parameters were passed by value.

[karapas]

Thanks for the replies guys! jacek you are right! I did not notice that such a thing could happen in the first place! I 've just noticed that the same code exists in STL <vector> as well and there is an enlightening comment:

_Ty _Tmp = _Val;	// in case _Val is in sequence

_Ty _Tmp = _Val;	// in case _Val is in sequence

To copy to clipboard, switch view to plain text mode 

Thanks again!

[Michiel]

Hm. Perhaps it is to ensure that the type has a public copy constructor? I'm not sure if a pass-by-value parameter would ensure the same thing.

[karapas]

Hm. Perhaps it is to ensure that the type has a public copy constructor? I'm not sure if a pass-by-value parameter would ensure the same thing.

I think that pass-by-value parameter does exactly the same thing i.e it calls the copy constructor to create a copy of the passed object.


I think that an optimazation would be to create the copy only when resize (i.e call realloc) is needed. This would possibly result in a bit larger code but it would probably be better not to needlessly invoke the copy constructor in case that large objects are stored inside the QVector (for example images)