QString :: is there some kind of "named place markers" (like in python string) ?

[lexar]

So, I think we are at the point to agree, there is no such thing like:

QString("%(one) %(two) %(three) %(four) ...").arg(qhash_dictionary);

QString("%(one) %(two) %(three) %(four) ...").arg(qhash_dictionary);

To copy to clipboard, switch view to plain text mode 

Creating only a single new heap object for the new string content.

1:0 for python

[high_flyer]

So, I think we are at the point to agree, there is no such thing like:

I didn't know that it was the debate ;-)

The question is, what is python doing behind the scenes.

Creating only a single new heap object for the new string content.

Well, not quite, since the dictionary has to have strings in it...
In the solution I offered you, you create a QHash, and a QRegExp, and that's it, so its not that much of difference in terms of memory usage.
From here on it s mostly splitting hairs.

[lexar]

I'm also not familiar with the python internals, the "1:0" is for the API.

Unfortunately your solution using regex does not fit the requirements: replacing bunch of different named-place-holders in a single string, avoiding temporary objects. (The place-holder strings (the keys) should not be counted, they exist in each case.)

Thanks anyway.

[high_flyer]

Unfortunately your solution using regex does not fit the requirements:

Why not?
Where do temporary objects are being created?

[lexar]

Where do temporary objects are being created?

each replace() call calls replace_helper(), which calls resize() with allocates a NEW, bigger heap block, for the growing string content.
Of course if you are lucky, and growing successes, you are done. It depends on memory fragmentation and system activity... See "void QString::resize(int size)".

[high_flyer]

each replace() call calls replace_helper(), which calls resize() with allocates a NEW, bigger heap block, for the growing string content.

That is simply not true.
That is only true (the resizing), if the resulting string is larger then the original string.
This can happen if your place holders are smaller then the string that replaces them. (line 18,41)
In such a case, more memory will be allocated for the resulting sting in any case.
Also note, that afterBuffer gets deleted at the end of the function, which means for each call not more then alen bytes will be allocated, and released (lines 61,65), and that too, only happens in the cases specified in the comment.

Here is the code:

void QString::replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen)
{
    // copy *after in case it lies inside our own d->data area
    // (which we could possibly invalidate via a realloc or corrupt via memcpy operations.)
    QChar *afterBuffer = const_cast<QChar *>(after);
    if (after >= reinterpret_cast<QChar *>(d->data) && after < reinterpret_cast<QChar *>(d->data) + d->size) {
        afterBuffer = static_cast<QChar *>(qMalloc(alen*sizeof(QChar)));
        Q_CHECK_PTR(afterBuffer);
        ::memcpy(afterBuffer, after, alen*sizeof(QChar));
    }
 
    QT_TRY {
        detach();
        if (blen == alen) {
            // replace in place
            for (int i = 0; i < nIndices; ++i)
                memcpy(d->data + indices[i], afterBuffer, alen * sizeof(QChar));
        } else if (alen < blen) {
            // replace from front
            uint to = indices[0];
            if (alen)
                memcpy(d->data+to, after, alen*sizeof(QChar));
            to += alen;
            uint movestart = indices[0] + blen;
            for (int i = 1; i < nIndices; ++i) {
                int msize = indices[i] - movestart;
                if (msize > 0) {
                    memmove(d->data + to, d->data + movestart, msize * sizeof(QChar));
                    to += msize;
                }
                if (alen) {
                    memcpy(d->data + to, afterBuffer, alen*sizeof(QChar));
                    to += alen;
                }
                movestart = indices[i] + blen;
            }
            int msize = d->size - movestart;
            if (msize > 0)
                memmove(d->data + to, d->data + movestart, msize * sizeof(QChar));
            resize(d->size - nIndices*(blen-alen));
        } else {
            // replace from back
            int adjust = nIndices*(alen-blen);
            int newLen = d->size + adjust;
            int moveend = d->size;
            resize(newLen);
 
            while (nIndices) {
                --nIndices;
                int movestart = indices[nIndices] + blen;
                int insertstart = indices[nIndices] + nIndices*(alen-blen);
                int moveto = insertstart + alen;
                memmove(d->data + moveto, d->data + movestart,
                        (moveend - movestart)*sizeof(QChar));
                memcpy(d->data + insertstart, afterBuffer, alen*sizeof(QChar));
                moveend = movestart-blen;
            }
        }
    } QT_CATCH(const std::bad_alloc &) {
        if (afterBuffer != after)
            qFree(afterBuffer);
        QT_RETHROW;
    }
    if (afterBuffer != after)
        qFree(afterBuffer);
}

void QString::replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen)
{
    // copy *after in case it lies inside our own d->data area
    // (which we could possibly invalidate via a realloc or corrupt via memcpy operations.)
    QChar *afterBuffer = const_cast<QChar *>(after);
    if (after >= reinterpret_cast<QChar *>(d->data) && after < reinterpret_cast<QChar *>(d->data) + d->size) {
        afterBuffer = static_cast<QChar *>(qMalloc(alen*sizeof(QChar)));
        Q_CHECK_PTR(afterBuffer);
        ::memcpy(afterBuffer, after, alen*sizeof(QChar));
    }

    QT_TRY {
        detach();
        if (blen == alen) {
            // replace in place
            for (int i = 0; i < nIndices; ++i)
                memcpy(d->data + indices[i], afterBuffer, alen * sizeof(QChar));
        } else if (alen < blen) {
            // replace from front
            uint to = indices[0];
            if (alen)
                memcpy(d->data+to, after, alen*sizeof(QChar));
            to += alen;
            uint movestart = indices[0] + blen;
            for (int i = 1; i < nIndices; ++i) {
                int msize = indices[i] - movestart;
                if (msize > 0) {
                    memmove(d->data + to, d->data + movestart, msize * sizeof(QChar));
                    to += msize;
                }
                if (alen) {
                    memcpy(d->data + to, afterBuffer, alen*sizeof(QChar));
                    to += alen;
                }
                movestart = indices[i] + blen;
            }
            int msize = d->size - movestart;
            if (msize > 0)
                memmove(d->data + to, d->data + movestart, msize * sizeof(QChar));
            resize(d->size - nIndices*(blen-alen));
        } else {
            // replace from back
            int adjust = nIndices*(alen-blen);
            int newLen = d->size + adjust;
            int moveend = d->size;
            resize(newLen);

            while (nIndices) {
                --nIndices;
                int movestart = indices[nIndices] + blen;
                int insertstart = indices[nIndices] + nIndices*(alen-blen);
                int moveto = insertstart + alen;
                memmove(d->data + moveto, d->data + movestart,
                        (moveend - movestart)*sizeof(QChar));
                memcpy(d->data + insertstart, afterBuffer, alen*sizeof(QChar));
                moveend = movestart-blen;
            }
        }
    } QT_CATCH(const std::bad_alloc &) {
        if (afterBuffer != after)
            qFree(afterBuffer);
        QT_RETHROW;
    }
    if (afterBuffer != after)
        qFree(afterBuffer);
}

To copy to clipboard, switch view to plain text mode 

[lexar]

That is simply not true.
That is only true (the resizing), if the resulting string is larger then the original string.

And in my world that is the most probably case: when the replacement is bigger then the place-marker (simplified):

1: QString("%(placeholder_for_streetname) %(placeholder_for_cityname)").arg({...:"sun street", ...:"suncity"})
2: QString("%(street) %(city)").arg({...:"simpsons road", ...:"springfeeld"})

// note: arg() is a fictive construct receiving a dictionary (just to demonstrate the dict content)

Thus this is _the_ true, at least for me...

[high_flyer]

Thus this is _the_ true, at least for me...

Please note exactly what I wrote in response to your:

regex does not fit the requirements:...avoiding temporary objects.

I showed you that no temp objects are being created.

What you wrote:

when the replacement is bigger then the place-marker (simplified):

Is about the resizing of the string, and this happens in any case/language/api, and has nothing to do with temp objects, in the case you are using too.

[lexar]

Forget it. Seems our understanding of efficiency is just too different.

Thanks anyway...