Сколько копий данных при возврате функции std::vector в функции и насколько большой будет оптимизация, нужно разместить std::vector в свободном хранилище (в куче) и вернуть указатель, а именно:
std::vector *f()
{
std::vector *result = new std::vector();
/*
Insert elements into result
*/
return result;
}
более эффективен, чем:
std::vector f()
{
std::vector result;
/*
Insert elements into result
*/
return result;
}
?
В С++ 11 это предпочтительный способ:
std::vector<X> f();
То есть, возвращаем значение.
С С++ 11, std::vector имеет перемещение-семантику, что означает, что локальный вектор, объявленный в вашей функции, будет перемещен при возврате, а в некоторых случаях даже перемещение может быть отменено компилятором.
Вы должны вернуться по значению.
Стандарт имеет определенную функцию для повышения эффективности возврата по значению. Он называется "копирование элиции", а точнее в этом случае - "Именованная оптимизация значения стоимости (NRVO)".
Компиляторам не нужно его реализовывать, но опять же компиляторам не нужно реализовывать функцию inline (или вообще выполнять какую-либо оптимизацию). Но производительность стандартных библиотек может быть довольно плохой, если компиляторы не оптимизируют, и все серьезные компиляторы реализуют inlining и NRVO (и другие оптимизации).
Когда применяется NRVO, в следующем коде копирование не будет:
std::vector<int> f() {
std::vector<int> result;
... populate the vector ...
return result;
}
std::vector<int> myvec = f();
Но пользователь может захотеть сделать это:
std::vector<int> myvec;
... some time later ...
myvec = f();
Копирование elision не предотвращает копию здесь, потому что это назначение, а не инициализация. Однако вы все равно должны вернуться по значению. В С++ 11 назначение оптимизируется чем-то другим, называемым "семантикой перемещения". В С++ 03 приведенный выше код действительно вызывает копию, и хотя теоретически оптимизатор может его избежать, на практике это слишком сложно. Поэтому вместо myvec = f(), в С++ 03 вы должны написать это:
std::vector<int> myvec;
... some time later ...
f().swap(myvec);
Существует еще один вариант, который предлагает пользователю более гибкий интерфейс:
template <typename OutputIterator> void f(OutputIterator it) {
... write elements to the iterator like this ...
*it++ = 0;
*it++ = 1;
}
Затем вы можете также поддерживать существующий векторный интерфейс поверх этого:
std::vector<int> f() {
std::vector<int> result;
f(std::back_inserter(result));
return result;
}
Это может быть менее эффективно, чем ваш существующий код, если ваш существующий код использует reserve() более сложным, чем просто фиксированная сумма. Но если ваш существующий код в основном называет push_back на векторе многократно, то этот шаблонный код должен быть таким же хорошим.
Я отправляю ответ RVO, мне тоже...
Если вы возвращаете объект по значению, компилятор часто оптимизирует его, поэтому он не создается дважды, так как излишне строить его в функции как временный, а затем копировать. Это называется оптимизацией возвращаемого значения: созданный объект будет перемещен, а не скопирован.
Распространенной идиомой до С++ 11 является передача ссылки на заполняемый объект.
Тогда нет копирования вектора.
void f( std::vector & result )
{
/*
Insert elements into result
*/
}
Если компилятор поддерживает Named Return Value Optimization (http://msdn.microsoft.com/en-us/library/ms364057(v=vs.80).aspx), вы можете прямо вернуть вектор, указав, что нет:
NRVO оптимизирует избыточные вызовы конструктора и деструктора и, таким образом, повышает общую производительность.
В вашем примере не должно быть реального различия.
vector<string> getseq(char * db_file)
И если вы хотите распечатать его на main(), вы должны сделать это в цикле.
int main() {
vector<string> str_vec = getseq(argv[1]);
for(vector<string>::iterator it = str_vec.begin(); it != str_vec.end(); it++) {
cout << *it << endl;
}
}
Да, вернитесь по значению. Компилятор может обрабатывать его автоматически.
vector<string> func1() const
{
vector<string> parts;
return vector<string>(parts.begin(),parts.end()) ;
} Так же хорошо, как "возврат по значению", это тип кода, который может привести к ошибке. Рассмотрим следующую программу:
#include <string>
#include <vector>
#include <iostream>
using namespace std;
static std::vector<std::string> strings;
std::vector<std::string> vecFunc(void) { return strings; };
int main(int argc, char * argv[]){
// set up the vector of strings to hold however
// many strings the user provides on the command line
for(int idx=1; (idx<argc); ++idx){
strings.push_back(argv[idx]);
}
// now, iterate the strings and print them using the vector function
// as accessor
for(std::vector<std::string>::interator idx=vecFunc().begin(); (idx!=vecFunc().end()); ++idx){
cout << "Addr: " << idx->c_str() << std::endl;
cout << "Val: " << *idx << std::endl;
}
return 0;
};
Вышеупомянутая ошибочная программа не укажет на ошибки, даже если вы используете параметры отчетности GNU g++ -Wall -Wextra -WeffС++
Если вы должны создать значение, то вместо вызова vecFunc() будет работать следующее:
std::vector<std::string> lclvec(vecFunc());
for(std::vector<std::string>::iterator idx=lclvec.begin(); (idx!=lclvec.end()); ++idx)...
Вышеизложенное также не создает анонимных объектов во время итерации цикла, но требует возможной операции копирования (которая в некоторых случаях может быть оптимизирована при некоторых обстоятельствах. Но ссылочный метод гарантирует, что копия не будет создана. компилятор выполнит RVO, не заменит попытку построить наиболее эффективный код, который вы можете. Если вы можете решить, нужно ли компилятору выполнять RVO, вы опережаете игру.