C ++ 11 — C ++, константная ссылка на самом деле быстрее, чем двигаться?

После тестирования этого кода:

#include <iostream>
#include <chrono>
#include <vector>
#include <string>void x(std::vector<std::string>&& v){ }

void y(const std::vector<std::string>& v) { }

int main() {
std::vector<std::string> v = {};

auto tp = std::chrono::high_resolution_clock::now();

for (int i = 0; i < 1000000000; ++i)
x(std::move(v));

auto t2 = std::chrono::high_resolution_clock::now();

auto time = std::chrono::duration_cast<std::chrono::duration<double>>(t2 - tp);

std::cout << "1- It took: "  << time.count() << " seconds\n";

tp = std::chrono::high_resolution_clock::now();

for (int i = 0; i < 1000000000; ++i)
y(v);

t2 = std::chrono::high_resolution_clock::now();

time = std::chrono::duration_cast<std::chrono::duration<double>>(t2 - tp);

std::cout << "2- It took: " << time.count() << " seconds\n";

std::cin.get();
}

Я понял, что использование const-reference на 15 секунд быстрее, чем использование семантики перемещения. Почему? Я думал, что семантика перемещения была быстрее, иначе зачем они их добавляют? Что я неправильно понял в семантике перемещения? Спасибо

-3

Решение

Ваш код не имеет смысла. Вот более простая версия вашего кода, замененная на int и убрал. Вот сборочная версия кода, скомпилированного с -std=c++11 -02:

https://goo.gl/6MWLNp

Нет никакой разницы между сборкой для функций rvalue и lvalue. Независимо от причины, не имеет значения, потому что сам тест не использует семантику перемещения.

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

Вот лучший пример, на этот раз, поменяв местами первые два элемента в векторе:

https://goo.gl/Sp6sk4

Как ни странно, вы можете видеть, что вторая функция фактически просто вызывает эталонную версию rvalue как часть своего выполнения.

Предполагая, что функция A, которая вызывает B, медленнее, чем просто выполнение функции B, скорость x() должен выиграть y(),


std::move() Сам имеет дополнительную стоимость. Все остальное постоянно, зовет std::move() дороже, чем не звонить std::move(), Вот почему «семантика перемещения» медленнее в коде, который вы нам дали. На самом деле код работает медленнее, потому что вы на самом деле ничего не делаете — обе функции просто возвращаются, как только они выполняются. Вы также можете увидеть, что одна версия появляется для вызова std::move() в то время как другой нет.

Изменить: вышеприведенное не похоже на правду. std::move() обычно не является истинным вызовом функции; это в основном static_cast<T&&> это зависит от некоторых шаблонов.

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

tl; dr: Вы на самом деле не используете семантику перемещения, потому что вашим функциям вообще ничего не нужно делать. Сделайте так, чтобы функции использовали копирование / перемещение, и вы увидите, что даже сборка использует часть кода «семантики перемещения» как часть своего кода копирования.

1

Другие решения

Других решений пока нет …

По вопросам рекламы ammmcru@yandex.ru
Adblock
detector