std :: องค์ประกอบเวกเตอร์รับประกันว่าจะติดกันหรือไม่

คำถามของฉันง่ายมาก: มีการรับประกันว่าองค์ประกอบของเวกเตอร์ std :: ติดกันหรือไม่ ตามลำดับคำฉันสามารถใช้ตัวชี้ไปยังองค์ประกอบแรกของ std :: vector เป็น C-array ได้หรือไม่

หากหน่วยความจำของฉันทำงานได้ดีมาตรฐาน C ++ ก็ไม่ได้รับประกันเช่นนั้น อย่างไรก็ตามข้อกำหนด std :: vector นั้นแทบจะเป็นไปไม่ได้เลยที่จะตอบสนองความต้องการเหล่านั้นหากองค์ประกอบไม่ติดกัน

ใครสามารถชี้แจงเรื่องนี้ได้บ้าง?

ตัวอย่าง:

std::vector<int> values;
// ... fill up values

if( !values.empty() )
{
    int *array = &values[0];
    for( int i = 0; i < values.size(); ++i )
    {
        int v = array[i];
        // do something with 'v'
    }
}

สิ่งนี้พลาดจากมาตรฐาน C ++ 98 ที่เหมาะสม แต่ต่อมาถูกเพิ่มเป็นส่วนหนึ่งของ TR แน่นอนว่ามาตรฐาน C ++ 0x ที่กำลังจะมาถึงจะมีสิ่งนี้เป็นข้อกำหนด

จาก n2798 (ร่าง C ++ 0x):

23.2.6 เวกเตอร์แม่แบบคลาส [เวกเตอร์]

1 เวกเตอร์เป็นคอนเทนเนอร์ลำดับที่รองรับตัววนซ้ำการเข้าถึงโดยสุ่ม นอกจากนี้ยังรองรับการแทรกเวลาคงที่ (ตัดจำหน่าย) และลบการดำเนินการในตอนท้าย แทรกและลบตรงกลางใช้เวลาเชิงเส้น การจัดการพื้นที่จัดเก็บจะได้รับการจัดการโดยอัตโนมัติแม้ว่าจะสามารถให้คำแนะนำเพื่อปรับปรุงประสิทธิภาพได้ องค์ประกอบของเวกเตอร์จะถูกจัดเก็บอย่างต่อเนื่องซึ่งหมายความว่าถ้า v เป็นเวกเตอร์โดยที่ T เป็นประเภทอื่นที่ไม่ใช่บูลมันจะเป็นไปตามเอกลักษณ์ & v [n] == & v [0] + n สำหรับทั้งหมด 0 <= n <v .ขนาด().

ดังที่คำตอบอื่น ๆ ได้ชี้ให้เห็นเนื้อหาของเวกเตอร์รับประกันว่าจะต่อเนื่อง (ยกเว้นความแปลกประหลาดของบูล)

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

ในความเป็นจริงมาตรฐานรับประกันว่า a vectorมีความต่อเนื่องในหน่วยความจำและ&a[0]สามารถส่งผ่านไปยังCฟังก์ชันที่ต้องการอาร์เรย์ได้

ข้อยกเว้นของกฎนี้คือvector<bool>ใช้เพียงหนึ่งบิตต่อboolดังนั้นแม้ว่ามันจะมีหน่วยความจำต่อเนื่อง แต่ก็ไม่สามารถใช้เป็น a ได้bool*(ถือว่าเป็นการเพิ่มประสิทธิภาพที่ผิดพลาดและผิดพลาด)

BTW ทำไมคุณไม่ใช้ตัวทำซ้ำ นั่นคือสิ่งที่พวกเขามีไว้สำหรับ

ดังที่คนอื่น ๆ ได้กล่าวไว้แล้วว่าvectorภายในใช้อาร์เรย์ของวัตถุที่อยู่ติดกัน ตัวชี้ในอาร์เรย์นั้นควรถือว่าไม่ถูกต้องเมื่อใดก็ตามที่ฟังก์ชันสมาชิกที่ไม่ใช่ const เรียกว่า IIRC

อย่างไรก็ตามมีข้อยกเว้น !!

vector<bool>มีการใช้งานเฉพาะที่ออกแบบมาเพื่อประหยัดพื้นที่ดังนั้นแต่ละบูลจึงใช้เพียงบิตเดียว อาร์เรย์พื้นฐานไม่ได้เป็นอาร์เรย์ที่ต่อเนื่องกันของบูลและการคำนวณบนอาร์เรย์vector<bool>ไม่ทำงานเช่นvector<T>หากว่า

(ฉันคิดว่าอาจเป็นไปได้ว่านี่อาจเป็นจริงสำหรับความเชี่ยวชาญพิเศษของเวกเตอร์เนื่องจากเราสามารถใช้งานใหม่ได้ตลอดเวลาอย่างไรก็ตามstd::vector<bool>เป็นเพียงความเชี่ยวชาญมาตรฐานเดียวที่ผิดพลาดมาตรฐานซึ่งการคำนวณทางคณิตศาสตร์ของตัวชี้อย่างง่ายจะใช้ไม่ได้)

ฉันพบหัวข้อนี้เพราะฉันมีกรณีการใช้งานที่เวกเตอร์ที่ใช้หน่วยความจำต่อเนื่องเป็นข้อดี

ฉันกำลังเรียนรู้วิธีใช้ออบเจ็กต์บัฟเฟอร์จุดยอดใน OpenGL ฉันสร้างคลาส wrapper เพื่อให้มีตรรกะของบัฟเฟอร์ดังนั้นสิ่งที่ฉันต้องทำก็คือส่งอาร์เรย์ของโฟลตและค่าคอนฟิกสองสามค่าเพื่อสร้างบัฟเฟอร์ ฉันต้องการสร้างบัฟเฟอร์จากฟังก์ชันตามอินพุตของผู้ใช้ดังนั้นจึงไม่ทราบความยาวในเวลาคอมไพล์ การทำสิ่งนี้จะเป็นวิธีแก้ปัญหาที่ง่ายที่สุด:

void generate(std::vector<float> v)
{
  float f = generate_next_float();
  v.push_back(f);
}

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

สิ่งนี้ดีกว่าการจัดสรรอาร์เรย์ขนาดใหญ่เพื่อจัดเก็บโฟลตและหวังว่าฉันจะทำให้มันใหญ่พอหรือสร้างไดนามิกอาร์เรย์ของตัวเองด้วยพื้นที่เก็บข้อมูลที่ต่อเนื่องกัน

cplusplus.com:

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

ใช่องค์ประกอบของ std :: vector รับประกันได้ว่าติดกัน