จำนวนข้อมูลที่ถูกคัดลอกเมื่อส่งคืน std :: vector ในฟังก์ชันและการเพิ่มประสิทธิภาพนั้นจะใหญ่เพียงใดในการวาง std :: vector ใน free-store (บน heap) และส่งกลับตัวชี้แทนนั่นคือ:
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;
}
เหรอ?
คำตอบ:
ใน C ++ 11 เป็นวิธีที่แนะนำ:
std::vector<X> f();
นั่นคือส่งคืนตามมูลค่า
ด้วย C ++ 11 std::vectorมีความหมายการเคลื่อนที่ซึ่งหมายความว่าเวกเตอร์โลคัลที่ประกาศในฟังก์ชันของคุณจะถูกย้ายเมื่อกลับมาและในบางกรณีคอมไพเลอร์ก็สามารถหลีกเลี่ยงการย้ายได้
std::move?
return std::move(v); return v;ดังนั้นจึงเป็นที่ต้องการ
คุณควรส่งคืนตามมูลค่า
มาตรฐานมีคุณลักษณะเฉพาะในการปรับปรุงประสิทธิภาพของการส่งคืนตามมูลค่า เรียกว่า "copy elision" และโดยเฉพาะอย่างยิ่งในกรณีนี้คือ "named return value optimization (NRVO)"
คอมไพเลอร์ไม่จำเป็นต้องใช้มัน แต่จากนั้นคอมไพเลอร์อีกครั้งก็ไม่จำเป็นต้องใช้ฟังก์ชัน 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();
การคัดลอกการคัดลอกไม่ได้ป้องกันการคัดลอกที่นี่เนื่องจากเป็นการมอบหมายงานแทนที่จะเป็นการเริ่มต้น อย่างไรก็ตามคุณควรยังคงกลับมาด้วยค่า ใน C ++ 11 งานจะได้รับการปรับให้เหมาะสมโดยสิ่งที่แตกต่างกันเรียกว่า "move semantics" ใน C ++ 03 โค้ดข้างต้นทำให้เกิดการคัดลอกและแม้ว่าในทางทฤษฎีเครื่องมือเพิ่มประสิทธิภาพอาจหลีกเลี่ยงได้ แต่ในทางปฏิบัติมันยากเกินไป ดังนั้นmyvec = f()ใน C ++ 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แล้วก็เช่นกัน ...
หากคุณส่งคืนอ็อบเจ็กต์ตามค่าคอมไพลเลอร์มักจะปรับให้เหมาะสมดังนั้นจึงไม่ถูกสร้างขึ้นสองครั้งเนื่องจากไม่จำเป็นที่จะสร้างวัตถุในฟังก์ชันเป็นการชั่วคราวแล้วคัดลอก สิ่งนี้เรียกว่าการเพิ่มประสิทธิภาพค่าส่งคืน: วัตถุที่สร้างขึ้นจะถูกย้ายแทนที่จะถูกคัดลอก
สำนวน pre-C ++ 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;
}
}
อาจจะดีพอ ๆ กับ "return by value" แต่ก็เป็นประเภทของรหัสที่สามารถนำไปสู่ข้อผิดพลาดได้ พิจารณาโปรแกรมต่อไปนี้:
#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 -Weffc ++
หากคุณต้องสร้างค่าสิ่งต่อไปนี้จะใช้แทนการเรียก vecFunc () สองครั้ง:
std::vector<std::string> lclvec(vecFunc());
for(std::vector<std::string>::iterator idx=lclvec.begin(); (idx!=lclvec.end()); ++idx)...
ข้างต้นยังไม่ก่อให้เกิดวัตถุที่ไม่ระบุตัวตนในระหว่างการวนซ้ำ แต่ต้องมีการดำเนินการคัดลอกที่เป็นไปได้ (ซึ่งตามบันทึกย่อบางส่วนอาจได้รับการปรับให้เหมาะสมภายใต้สถานการณ์บางอย่าง แต่วิธีการอ้างอิงจะรับประกันว่าจะไม่มีการสร้างสำเนาขึ้นโดยเชื่อว่าคอมไพเลอร์จะ การดำเนินการ RVO ไม่ใช่สิ่งทดแทนสำหรับการพยายามสร้างโค้ดที่มีประสิทธิภาพสูงสุดเท่าที่จะทำได้หากคุณสามารถตัดความต้องการให้คอมไพเลอร์ทำ RVO ได้แสดงว่าคุณเป็นผู้นำเกม
vector<string> func1() const
{
vector<string> parts;
return vector<string>(parts.begin(),parts.end()) ;
}
f?