Как проверить эллизионную копию С++

Я думаю, что это очень часто применяемая оптимизация, потому что:

1. компилятору не сложно это сделать
2. это может быть большой выигрыш
3. это область C++, которая часто подвергалась критике до того, как оптимизация стала обычным явлением.

Если вам просто интересно, поместите отладку printf() в свой конструктор копирования:

class foo {
public:
    foo(): x(0) {};

    foo(int x_) : x( x_) {};

    foo( foo const& other) : x( other.x) {
        printf( "copied a foo\n");
    };

    static foo foobar() {
        foo tmp( 2);

        return tmp;
    }


private:
    int x;
};



int main()
{
    foo myFoo;

    myFoo = foo::foobar();

    return 0;
}

Распечатывает «скопировано foo», когда я запускаю неоптимизированную сборку, но ничего, когда я оптимизирую сборку.

Из цитируемой вами статьи:

Хотя стандарт никогда не требует исключения копирования, последние версии каждого протестированного мной компилятора сегодня выполняют эту оптимизацию. Но даже если вам неудобно возвращать тяжеловесные объекты по значению, исключение копирования все равно должно изменить способ написания кода.

Он более известен как оптимизация возвращаемого значения.

Единственный способ узнать наверняка - посмотреть на сборку, но вы задаете неправильный вопрос. Вам не нужно знать, пропускает ли компилятор копию, если это не имеет значения для времени выполнения программы. Профилировщик должен легко сказать вам, если вы проводите слишком много времени в конструкторе копирования.

Способ бедняка понять это - поместить статический счетчик в конструктор копирования и попробовать обе формы вашей функции. Если счетчики совпадают, вы успешно избежали копирования.

Вместо этого погуглите «Оптимизация именованного возвращаемого значения» и «Оптимизация возвращаемого значения». Фактически современные компиляторы во многих случаях не будут выполнять копирование.

Вы можете проверить, происходит ли это, возвращая тип с побочными эффектами, такими как печать сообщения. В Википедии есть несколько хороших примеров того, где выходные данные программы меняются, когда действует RVO и/или NRVO.

Пример того, как это выглядит:

#include <iostream>

struct Foo {
    int a;
    Foo(int a) : a(a) {}
    Foo(const Foo &rhs) : a(rhs.a) { std::cout << "copying\n"; }
};

int main() {
    Foo f = Foo(1);
}

Если вы не видите вывода, значит, произошло удаление копии. Это исключение копии из инициализатора. Другим допустимым случаем исключения копии является возвращаемое значение, и оно проверяется:

Foo getFoo() {
    return Foo(1);
}

int main() {
    Foo f = getFoo();
}

или более интересно для именованного возвращаемого значения:

Foo getFoo() {
    Foo f(1);
    return f;
}

int main() {
    Foo f = getFoo();
}

g++ выполняет для меня все эти исключения без флагов оптимизации, но вы не можете точно знать, сможет ли более сложный код перехитрить компилятор.

Обратите внимание, что исключение копирования не помогает при присваивании, поэтому следующее всегда будет приводить к вызову operator=, если этот оператор что-либо печатает:

Foo f(1);
f = getFoo();

Таким образом, возврат по значению может привести к "копии", даже если выполняется исключение конструктора копирования. Таким образом, для разделения больших классов на этапе проектирования все еще необходимо учитывать производительность. Вы не хотите писать свой код таким образом, что его исправление позже будет иметь большое значение, если окажется, что ваше приложение тратит значительную часть своего времени на копирование, которого можно было бы избежать.

Чтобы ответить на вопрос 2, вы можете написать демонстрационную программу, в которой вы пишете class DemoReturnType; с инструментальными конструкторами и деструкторами, которые просто пишут в cout при вызове. Это должно дать вам достаточно информации о том, на что способен ваш компилятор.

Ссылки Rvalue решают эту проблему в C++0x. Другой вопрос, можете ли вы получить компилятор с поддержкой rvalue - в прошлый раз я проверял, что его поддерживает только Visual Studio 2010.