Улучшения производительности C++ 0x

Question

Одним из улучшений C++ 0x, которые позволят написать более эффективный код на C++, является интеллектуальный указатель unique_ptr (слишком плохо, что он не позволит перемещаться по memmove() как операции: предложение не внесены в проект).

Каковы другие улучшения производительности в предстоящем стандарте? Возьмем следующий код, например:

vector<char *> v(10,"astring"); 
string concat = accumulate(v.begin(),v.end(), string("")); 

код будет сцеплять все строки, содержащиеся в векторе v. Проблема с этой аккуратной частью кода заключается в том, что accumulate() копирует вещи вокруг и не использует ссылки. И строка() перераспределяет каждый раз, когда вызывается оператор. Таким образом, код имеет низкую производительность по сравнению с хорошо оптимизированным аналоговым кодом C.

Предоставляет ли C++ 0x инструменты для решения проблемы и, возможно, другие?

Answer 1

Да C++ решает проблему через что-то называемое перемещение семантики.

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

Это делается путем введения конструктора перемещения . Его конструктор, где вы знаете, что объект src является временным и уходит. Поэтому для получателя приемлемо принимать внутреннее представление объекта src.

То же самое верно для Операции назначения переезда.

Чтобы отличить конструктор копирования от конструктора перемещения, язык ввел ссылки rvalue. Класс определяет свой конструктор перемещения, чтобы получить ссылку rvalue, которая будет привязана только к rvalues ​​(temporaries). Так что мой класс будет определить что-то вдоль линий:

class CMyString 
{ 
private: 
    char* rawStr; 
public: 

    // move constructor bound to rvalues 
    CMyString(CMyString&& srcStr) 
    { 
     rawStr = srcStr.rawStr 
     srcStr.rawStr = NULL;    
    } 

    // move assignment operator 
    CMyString& operator=(CMyString&& srcStr) 
    { 
     if(rawStr != srcStr.rawStr) // protect against self assignment 
     { 
      delete[] rawStr; 
      rawStr = srcStr.rawStr 
      srcStr.rawStr = NULL; 
     } 
     return *this; 
    } 

    ~CMyString() 
    { 
     delete [] rawStr; 
    } 
} 

Here очень хорошая и подробная статья по ходу семантики и синтаксиса, что позволяет сделать это.

Answer 2

Одним повышением производительности являются обобщенные постоянные выражения, которые вводятся ключевым словом constexpr.

constexpr int returnSomething() {return 40;} 

int avalue[returnSomething() + 2]; 

Это не законный код на C++, поскольку returnSomething() + 2 не является постоянным выражением.

Но, используя ключевое слово constexpr, C++ 0x может сообщить компилятору, что выражение является константой времени компиляции.

Answer 3

Извините - вы не можете утверждать как факт, что string concat = accumulate(v.begin(),v.end(), string(""));должно перераспределить. Разумеется, простая реализация. Но компиляторам очень разрешено делать правильные вещи здесь.

Это уже имеет место в C++ 98, а C++ 0x продолжает использовать как умные, так и немые реализации. Тем не менее, перемещение семантики упростит интеллектуальные реализации.

Answer 4

vector<string> v(10, "foo"); 
string concat = accumulate(v.begin(), v.end(), string("")); 

Этот пример - просто плохое программирование на любом стандарте C++. Это эквивалентно следующему:

string tmp; 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 
tmp = tmp + "foo"; //copy tmp, append "foo", then copy the result back into tmp 

C++ 11 двигаться семантика будет принимать только заботиться о «копировать результат обратно в TMP» части уравнения. Начальные копии от tmp все равно будут копиями. Это классический Schlemiel the Painter's algorithm, но еще хуже, чем обычно, например, с использованием strcat в С.

Если accumulate просто использовали += вместо + и = тогда это было бы избежать всех этих копий.

Но C++ 11 действительно дает нам возможность сделать лучше, оставаясь при этом лаконичным, используя функцию лямбды:

string concat; 
for_each(v.begin(), v.end(), [&](const string &s){ concat += s; }); 

EDIT: Я полагаю, стандартная библиотека реализатор может выбрать для реализации accumulate с ходом на операнд +, так что tmp = tmp + "foo" стал бы tmp = move(tmp) + "foo", и это решило бы эту проблему. Я не уверен, что такая реализация будет строго соответствовать. В настоящее время ни GCC, ни MSVC, ни LLVM не делают этого. А так как accumulate определен в <numeric>, можно предположить, что он предназначен только для использования с числовыми типами.