Как да проверите за копиране на C++ ellision

Мисля, че това е много често прилагана оптимизация, защото:

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

Ако просто сте любопитни, поставете debug 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;
}

Отпечатва „copied a foo“, когато стартирам неоптимизирана компилация, но нищо, когато компилирам оптимизирана.

От цитираната от вас статия:

Въпреки че elision никога не се изисква от стандарта, последните версии на всеки компилатор, който съм тествал, изпълняват тези оптимизации днес. Но дори и да не се чувствате комфортно да връщате тежки обекти по стойност, копирането на elision все пак трябва да промени начина, по който пишете код.

По-известен е като оптимизиране на възвръщаемата стойност.

Единственият начин да разберете със сигурност е да погледнете сборката, но задавате грешен въпрос. Не е необходимо да знаете дали компилаторът премахва копието, освен ако това няма значение за времето на програмата. Профайлърът би трябвало лесно да ви каже, ако прекарвате твърде много време в конструктора за копиране.

Начинът на бедния човек да го разбере е да постави статичен брояч в конструктора за копиране и да опита и двете форми на вашата функция. Ако броят е еднакъв, успешно сте избегнали копието.

Вместо това потърсете в Google „Оптимизация на наименувана възвръщаема стойност“ и „Оптимизация на възвръщаема стойност“. Съвременните компилатори всъщност няма да изпълнят копирането в много случаи.

Можете да проверите дали се случва, като върнете тип със странични ефекти - като отпечатване на съобщение. Wikipedia има някои добри примери за това къде изходът на програмата се променя, когато 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++ изпълнява всички тези елизии за мен без флагове за оптимизация, но всъщност не можете да знаете дали по-сложен код ще надхитри компилатора.

Имайте предвид, че elision за копиране не помага при присвояването, така че следното винаги ще доведе до извикване на operator=, ако този оператор отпечата нещо:

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

Следователно връщането по стойност все още може да доведе до "копие", дори ако се извърши премахване на конструктора на копиране. Така че за разделянето на страхотни класове все още е съображение за производителност на етапа на проектиране. Не искате да пишете кода си така, че поправката му по-късно да бъде голяма работа, ако се окаже, че приложението ви прекарва значителна част от времето си в копиране, което е можело да бъде избегнато.

За да отговорите на въпрос 2, можете да напишете демонстрационна програма, в която пишете class DemoReturnType;, която има инструментирани конструктори и деструктори, които просто пишат в cout, когато бъдат извикани. Това трябва да ви даде достатъчно информация за това на какво е способен вашият компилатор.

Rvalue препратките решават този проблем в C++0x. Друг е въпросът дали можете или не да получите компилатор с активиран rvalue - последния път, когато проверих, само Visual Studio 2010 го поддържа.