วิธีการเริ่มต้น std :: vector จากอาร์เรย์ C-style?

วิธีที่ถูกที่สุดในการเริ่มต้นstd::vectorอาร์เรย์จาก C-style คืออะไร?

ตัวอย่าง: ในคลาสต่อไปนี้ฉันมีvectorแต่เนื่องจากข้อ จำกัด ภายนอกข้อมูลจะถูกส่งผ่านเป็นอาร์เรย์สไตล์ C:

class Foo {
  std::vector<double> w_;
public:
  void set_data(double* w, int len){
   // how to cheaply initialize the std::vector?
}

เห็นได้ชัดว่าผมสามารถโทรและห่วงแล้วกว่าองค์ประกอบหรือโทรw_.resize() std::copy()มีวิธีการที่ดีกว่านี้ไหม?

อย่าลืมว่าคุณสามารถใช้พอยน์เตอร์เป็นตัววนซ้ำได้:

w_.assign(w, w + len);

คุณใช้คำว่าการเตรียมใช้งานดังนั้นจึงไม่ชัดเจนหากเป็นการมอบหมายแบบครั้งเดียวหรืออาจเกิดขึ้นหลายครั้ง

หากคุณต้องการการกำหนดค่าเริ่มต้นเพียงครั้งเดียวคุณสามารถกำหนดไว้ในตัวสร้างและใช้ตัวสร้างเวกเตอร์ตัววนซ้ำสองตัว:

Foo::Foo(double* w, int len) : w_(w, w + len) { }

มิฉะนั้นให้ใช้การมอบหมายตามที่แนะนำไว้ก่อนหน้านี้:

void set_data(double* w, int len)
{
    w_.assign(w, w + len);
}

คุณสามารถ 'เรียนรู้' ขนาดของอาร์เรย์โดยอัตโนมัติ:

template<typename T, size_t N>
void set_data(const T (&w)[N]){
    w_.assign(w, w+N);
}

หวังว่าคุณสามารถเปลี่ยนอินเตอร์เฟสเป็น set_data ได้ มันยังคงยอมรับอาร์เรย์สไตล์ C เป็นอาร์กิวเมนต์แรก มันเพิ่งเกิดขึ้นที่จะใช้มันโดยการอ้างอิง

มันทำงานอย่างไร

[อัปเดต: ดูที่นี่สำหรับการอภิปรายที่ครอบคลุมมากขึ้นเกี่ยวกับการเรียนรู้ขนาด]

นี่เป็นวิธีแก้ปัญหาทั่วไปเพิ่มเติม:

template<typename T, size_t N>
void copy_from_array(vector<T> &target_vector, const T (&source_array)[N]) {
    target_vector.assign(source_array, source_array+N);
}

วิธีนี้ใช้งานได้เนื่องจากอาเรย์ถูกส่งผ่านเป็นการอ้างอิงไปยังอาเรย์ ใน C / C ++ คุณไม่สามารถผ่านอาร์เรย์เป็นฟังก์ชั่นแทนมันจะสลายตัวไปยังตัวชี้และคุณสูญเสียขนาด แต่ใน C ++ คุณสามารถส่งการอ้างอิงไปยังอาร์เรย์ได้

ผ่านอาร์เรย์โดยอ้างอิงต้องใช้ประเภทให้ตรงทั้งหมด ขนาดของอาร์เรย์เป็นส่วนหนึ่งของชนิด ซึ่งหมายความว่าเราสามารถใช้พารามิเตอร์เทมเพลต N เพื่อเรียนรู้ขนาดสำหรับเรา

มันอาจจะง่ายกว่าถ้ามีฟังก์ชันนี้ซึ่งคืนค่าเวกเตอร์ ด้วยการปรับให้เหมาะสมของคอมไพเลอร์ที่มีผลบังคับใช้สิ่งนี้ควรเร็วกว่าที่ควรจะเป็น

template<typename T, size_t N>
vector<T> convert_array_to_vector(const T (&source_array)[N]) {
    return vector<T>(source_array, source_array+N);
}

พาเวลอยู่ใกล้ แต่ก็มีวิธีที่ง่ายและสง่างามกว่าในการเริ่มต้นคอนเทนเนอร์ตามลำดับจากอาร์เรย์สไตล์ ac

ในกรณีของคุณ:

w_ (array, std::end(array))

• อาร์เรย์จะทำให้เราได้ตัวชี้ไปยังจุดเริ่มต้นของอาร์เรย์ (ไม่พบชื่อมัน)
• std :: end (array) จะทำให้เราเป็นตัววนซ้ำไปยังจุดสิ้นสุดของอาร์เรย์

คำตอบทั่วไปอย่างรวดเร็ว:

std::vector<double> vec(carray,carray+carray_size); 

หรือคำถามเฉพาะ:

std::vector<double> w_(w,w+len); 

ตามข้างต้น : อย่าลืมว่าคุณสามารถใช้พอยน์เตอร์เป็นตัววนซ้ำได้

std::vector<double>::assignเป็นวิธีที่จะไปเพราะมันเป็นรหัสเล็ก ๆ น้อย ๆ แต่มันใช้งานได้จริงอย่างไร มันไม่ได้ปรับขนาดแล้วคัดลอก? ในการใช้ MS ของ STL ฉันใช้มันทำอย่างนั้น

ฉันกลัวมีไม่ได้เร็วขึ้นวิธีที่จะใช้ (อีกครั้ง) std::vectorการเริ่มต้นของคุณ