Std :: vector öğelerinin bitişik olması garantili mi?

Sorum basit: std :: vektör öğelerinin bitişik olması garantili mi? Kelime sırasına göre, göstericiyi bir std :: vektörün ilk elemanına C-dizisi olarak kullanabilir miyim?

Hafızam bana iyi hizmet ediyorsa, C ++ standardı böyle bir garanti vermedi. Bununla birlikte, std :: vektör gereksinimleri öyledir ki, öğeler bitişik değilse bunları karşılamak neredeyse imkansızdır.

Biri bunu açıklayabilir mi?

Misal:

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'
    }
}

Bu, C ++ 98 standardından tam olarak kaçırıldı, ancak daha sonra bir TR'nin parçası olarak eklendi. Önümüzdeki C ++ 0x standardı elbette bunu bir gereklilik olarak içerecektir.

N2798'den (C ++ 0x taslağı):

23.2.6 Sınıf şablon vektörü [vektör]

1 Bir vektör, rastgele erişim yineleyicileri destekleyen bir sıra kapsayıcısıdır. Ek olarak, sonunda sabit zamanlı ekleme ve silme işlemlerini (amorti edilmiş) destekler; Ortada eklemek ve silmek doğrusal zaman alır. Depolama yönetimi otomatik olarak yapılır, ancak verimliliği artırmak için ipuçları verilebilir. Bir vektörün elemanları bitişik olarak depolanır, yani v, T'nin bool dışında bir tür olduğu bir vektörse, o zaman tüm 0 <= n <v için & v [n] == & v [0] + n kimliğine itaat eder. .boyut().

Diğer yanıtların da işaret ettiği gibi, bir vektörün içeriğinin sürekli olması garantilidir (bool'un tuhaflığı hariç).

Eklemek istediğim yorum şudur: Vektör üzerinde, vektörün belleğini yeniden tahsis etmesine neden olabilecek bir ekleme veya silme işlemi yaparsanız, kaydedilen tüm işaretçilerinizin ve yineleyicilerinizin geçersiz olmasına neden olursunuz.

Standart aslında a'nın vectorbellekte sürekli olduğunu ve bunun bir dizi bekleyen bir işleve &a[0]geçirilebileceğini garanti etmez C.

Bu kuralın istisnası, vector<bool>her biri için yalnızca bir bit kullanmasıdır , bu boolnedenle sürekli belleğe sahip olmasına rağmen, bir olarak kullanılamaz bool*(bu genellikle yanlış bir optimizasyon ve bir hata olarak kabul edilir).

BTW, neden yineleyiciler kullanmıyorsun? Onlar bunun için.

Diğerlerinin daha önce de söylediği gibi, vectordahili olarak bitişik bir nesne dizisi kullanır. Sabit olmayan herhangi bir üye işlev IIRC olarak adlandırıldığında bu diziye işaretçiler geçersiz olarak değerlendirilmelidir.

Ancak, bir istisna var !!

vector<bool>yerden tasarruf etmek için tasarlanmış özel bir uygulamaya sahiptir, böylece her bool yalnızca bir bit kullanır. Temeldeki dizi bitişik bir bool dizisi vector<bool>değildir ve dizi aritmetiği açık olduğu gibi çalışmaz vector<T>.

(Her zaman yeni bir tane uygulayabildiğimiz için, bunun herhangi bir vektör uzmanlaşması için de geçerli olabileceğini düşünüyorum. Bununla birlikte, std::vector<bool>basit işaretçi aritmetiğinin çalışmayacağı tek, hatalı, standart uzmanlıktır.)

Bu iş parçacığını buldum çünkü bitişik bellek kullanan vektörlerin bir avantaj olduğu bir kullanım durumum var.

OpenGL'de köşe tampon nesnelerini nasıl kullanacağımı öğreniyorum. Tampon mantığını içerecek bir sarmalayıcı sınıfı yarattım, bu yüzden tek yapmam gereken tampon oluşturmak için bir dizi float ve birkaç yapılandırma değeri geçirmek. Kullanıcı girdisine dayalı bir işlevden bir arabellek oluşturabilmek istiyorum, bu nedenle uzunluk derleme zamanında bilinmiyor. Bunun gibi bir şey yapmak en kolay çözüm olacaktır:

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

Şimdi vektörün yüzer sayılarını bir dizi olarak OpenGL'nin tamponla ilgili işlevlerine geçirebilirim. Bu aynı zamanda dizinin uzunluğunu belirlemek için sizeof gereksinimini de ortadan kaldırır.

Bu, kayan sayıları depolamak için büyük bir dizi ayırmaktan ve onu yeterince büyük yaptığımı ummaktan veya bitişik depolama ile kendi dinamik dizimi yapmaktan çok daha iyidir.

cplusplus.com:

Vektör kapları dinamik diziler olarak uygulanır; Tıpkı normal dizilerde olduğu gibi, vektör konteynerlerinin de öğeleri bitişik depolama konumlarında depolanır; bu, öğelerine yalnızca yineleyiciler kullanılarak değil, aynı zamanda öğelere yönelik normal işaretçilerdeki ofsetler kullanılarak da erişilebileceği anlamına gelir.

Evet, std :: vector öğelerinin bitişik olması garantilidir.