Ne kadar veri kopyalanır, bir işlevde bir std :: vektörü döndürülürken ve std :: vektörü serbest depoya (yığın üzerine) yerleştirmek ve bunun yerine bir işaretçi döndürmek ne kadar büyük bir optimizasyon olacaktır:
std::vector *f()
{
std::vector *result = new std::vector();
/*
Insert elements into result
*/
return result;
}
şundan daha verimli:
std::vector f()
{
std::vector result;
/*
Insert elements into result
*/
return result;
}
?
Yanıtlar:
C ++ 11'de bu tercih edilen yoldur:
std::vector<X> f();
Yani, değere göre dönüş.
C ++ 11 ile, std::vectorhareket-anlambilimine sahiptir, bu , fonksiyonunuzda bildirilen yerel vektörün dönüşte taşınacağı ve bazı durumlarda hareketin bile derleyici tarafından atlanabileceği anlamına gelir.
std::movemı?
return std::move(v);adaletle mümkün olsa bile hamle seçimini devre dışı bırakır return v;. Bu yüzden ikincisi tercih edilir.
Değere göre dönmelisiniz.
Standart, değere göre geri dönüş verimliliğini artırmak için belirli bir özelliğe sahiptir. Buna "kopya elizyonu" denir ve daha özel olarak bu durumda "adlandırılmış dönüş değeri optimizasyonu (NRVO)".
Derleyiciler uygulamak gerekmez, ama sonra tekrar derleyiciler yok olması inlining işlevi uygulamak için (ya da hiç bir optimizasyon gerçekleştirmek). Ancak, derleyiciler optimize etmezse ve tüm ciddi derleyiciler satır içi ve NRVO (ve diğer optimizasyonlar) uygularsa standart kitaplıkların performansı oldukça zayıf olabilir.
NRVO uygulandığında, aşağıdaki kodda herhangi bir kopyalama olmayacaktır:
std::vector<int> f() {
std::vector<int> result;
... populate the vector ...
return result;
}
std::vector<int> myvec = f();
Ancak kullanıcı bunu yapmak isteyebilir:
std::vector<int> myvec;
... some time later ...
myvec = f();
Kopyalama seçimi burada bir kopyayı engellemez çünkü bu bir başlatma değil atamadır. Ancak yine de değere göre dönmelisiniz. C ++ 11'de atama, "taşıma semantiği" adı verilen farklı bir şeyle optimize edilir. C ++ 03'te, yukarıdaki kod bir kopyaya neden olur ve teoride bir eniyileyici bundan kaçınabilir, ancak pratikte çok zordur. Yani myvec = f(), C ++ 03 yerine şunu yazmalısınız:
std::vector<int> myvec;
... some time later ...
f().swap(myvec);
Kullanıcıya daha esnek bir arayüz sunmak olan başka bir seçenek daha var:
template <typename OutputIterator> void f(OutputIterator it) {
... write elements to the iterator like this ...
*it++ = 0;
*it++ = 1;
}
Bunun üzerine mevcut vektör tabanlı arayüzü de destekleyebilirsiniz:
std::vector<int> f() {
std::vector<int> result;
f(std::back_inserter(result));
return result;
}
Bu belki senin kod kullanımları mevcut ise, varolan kodun daha az verimli olması reserve()ön sadece sabit bir miktardan daha fazla karmaşık bir şekilde. Ancak mevcut kodunuz temelde push_backvektörü tekrar tekrar çağırıyorsa , o zaman bu şablon tabanlı kodun o kadar iyi olması gerekir.
RVO hakkında bir cevap gönderme zamanım geldi , ben de ...
Bir nesneyi değere göre döndürürseniz, derleyici genellikle bunu en iyi duruma getirir, böylece onu işlevde geçici olarak inşa etmek ve sonra kopyalamak gereksiz olduğu için iki kez inşa edilmez. Buna dönüş değeri optimizasyonu denir: oluşturulan nesne kopyalanmak yerine taşınacaktır.
Yaygın bir pre-C ++ 11 deyimi, doldurulmakta olan nesneye bir başvuru iletmektir.
O zaman vektörün kopyalanması yok.
void f( std::vector & result )
{
/*
Insert elements into result
*/
}
Derleyici, Adlandırılmış Dönüş Değeri Optimizasyonunu ( http://msdn.microsoft.com/en-us/library/ms364057(v=vs.80).aspx ) destekliyorsa , aşağıdakilerin olmaması koşuluyla doğrudan vektörü döndürebilirsiniz:
NRVO, yedek kopya yapıcı ve yıkıcı çağrılarını optimize eder ve böylece genel performansı iyileştirir.
Örneğinizde gerçek bir fark olmamalıdır.
vector<string> getseq(char * db_file)
Ve eğer main () 'e yazdırmak istiyorsanız, bunu bir döngü içinde yapmalısınız.
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;
}
}
"Değere göre dönüş" ne kadar güzel olursa olsun, bu, birini hataya götürebilecek türden bir koddur. Aşağıdaki programı düşünün:
#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;
};
Yukarıdaki hatalı program, GNU g ++ raporlama seçeneklerini kullansa bile hata göstermeyecektir -Wall -Wextra -Weffc ++
Bir değer üretmeniz gerekiyorsa, vecFunc () öğesini iki kez çağırmak yerine aşağıdakiler çalışır:
std::vector<std::string> lclvec(vecFunc());
for(std::vector<std::string>::iterator idx=lclvec.begin(); (idx!=lclvec.end()); ++idx)...
Yukarıdakiler ayrıca döngünün yinelenmesi sırasında anonim nesneler üretmez, ancak olası bir kopyalama işlemi gerektirir (bazı notlara göre, bazı durumlarda optimize edilebilir. Ancak referans yöntemi hiçbir kopyanın üretilmeyeceğini garanti eder. Derleyicinin yapacağına inanmak RVO gerçekleştirmek, yapabileceğiniz en verimli kodu oluşturmaya çalışmanın yerini tutmaz.Eğer derleyicinin RVO yapma ihtiyacını karşılayabilirseniz, oyunda öndesiniz demektir.
f?