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

[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...