'Yeni' ve 'sil' C ++ 'da kullanımdan kaldırılıyor mu?

Farklı boyutlarda dizi bildirimi içeren bir sınav tökezledi. Aklıma gelen ilk şey şu newkomutla dinamik ayırma kullanmanız gerekecekti , şöyle:

while(T--) {
   int N;
   cin >> N;
   int *array = new int[N];
   // Do something with 'array'
   delete[] array;
}

Ancak, çözümlerden birinin aşağıdaki duruma izin verdiğini gördüm:

while(T--) {
    int N;
    cin >> N;
    int array[N];
    // Do something with 'array'
}

Biraz araştırma yaptıktan sonra g ++ 'nın buna izin verdiğini okudum, ancak beni düşünmeye devam etti, hangi durumlarda dinamik ayırma kullanmak gerekli? Yoksa derleyici bunu dinamik ayırma olarak mı çeviriyor?

Silme işlevi dahildir. Bununla birlikte, buradaki sorunun bellek sızıntıları ile ilgili olmadığını unutmayın.

Gösterdiğiniz snippet'in hiçbiri deyimsel, modern C ++ kodu değildir.

newve delete(ve new[]ve delete[]) C ++ 'da kullanımdan kaldırılmamıştır ve asla kullanılmayacaktır. Onlar hala dinamik olarak ayrılmış nesne örneğini oluşturmak için bir yol. Ancak, sahip olduğu zaman bir maç için bir ile (ve bir bir ile , onlar sizin için Bunu sağlamak (kitaplık) sınıfları içinde muhafaza en iyisidir). Bkz. C ++ programcıları 'yeni' kullanımını neden en aza indirmeli? .newdeletenew[]delete[]

İlk snippet'iniz bir "çıplak" kullanır new[]ve daha sonra delete[]oluşturulan diziyi asla içermez. Bu bir sorun. std::vectorBurada ihtiyacınız olan her şey gayet iyi. newSahnelerin bir çeşit biçimini kullanacak (uygulama ayrıntılarına dalmayacağım), ancak bakmanız gereken her şey için dinamik bir dizi ama daha iyi ve daha güvenli.

İkinci snippet'iniz, bazı derleyicilerin bir uzantı olarak C ++ 'da izin verdiği bir C özelliği olan "değişken uzunluklu diziler" (VLA) kullanır . Bunun aksine new, VLA'lar esas olarak yığına tahsis edilir (çok sınırlı bir kaynak). Ancak daha da önemlisi, standart bir C ++ özelliği değildir ve taşınabilir olmadıklarından kaçınılmalıdır. Kesinlikle dinamik (yani yığın) tahsisinin yerini almazlar.

Yeni başlayanlar için, new/ deletekullanımdan kaldırılmıyor.

Sizin durumunuzda, tek çözüm onlar değil. Seçtiğiniz şey, "dizi ile bir şeyler yapın" yorumunuz altında nelerin gizlendiğine bağlıdır.

2. örneğiniz, diziyi yığına sığdırmaya çalışan standart olmayan bir VLA uzantısı kullanır. Bunun belirli sınırlamaları vardır - sınırlı boyut ve dizi kapsam dışına çıktıktan sonra bu belleği kullanamama. Dışarı taşıyamazsınız, yığın çözüldükten sonra "kaybolacaktır".

Tek amacınız yerel bir hesaplama yapmak ve ardından verileri atmaksa, aslında işe yarayabilir. Bununla birlikte, hafızayı dinamik olarak, tercihen ile ayırmak daha sağlam bir yaklaşım olacaktır std::vector. Bu şekilde, bir çalışma zamanı değerine dayanarak ihtiyacınız olduğu kadar çok öğe için alan yaratma yeteneğine sahip olursunuz (bu, her şey için gidiyoruz), ancak aynı zamanda kendini güzelce temizler ve taşıyabilirsiniz belleği daha sonra kullanmak için bu kapsamda kullanın.

Başlangıca geri dönmek vector , muhtemelen newbirkaç kat daha derin kullanacaktır , ancak bununla ilgilenmemelisiniz, çünkü sunduğu arayüz çok daha üstündür. Bu anlamda kullanmak newve deletecesaretini kırmak düşünülebilir.

İkinci örnekleriniz , aslında bir C99 ( C ++! Değil ) özelliği olan, ancak yine de g ++ tarafından desteklenen değişken uzunluklu diziler (VLA'lar) kullanır .

Ayrıca bu cevaba bakınız .

Değişken uzunlukta diziler farklı olduğunu Not new/ deleteve onlara hiçbir şekilde "Kullanımdan kaldırma" yok.

VLA'ların ISO C ++ olmadığını da unutmayın .

Modern C ++, dinamik ayırmalarla çalışmanın daha kolay yollarını sunar. Akıllı işaretçiler, atıfta bulunulan veri yapıları kapsam dışına çıkar çıkmaz istisnalar (izin verilirse herhangi bir yerde olabilir) ve erken dönüşlerden sonra temizlemeye dikkat edebilir, bu nedenle bunları kullanmak mantıklı olabilir:

  int size=100;

  // This construct requires the matching delete statement.
  auto buffer_old = new int[size];

  // These versions do not require `delete`:
  std::unique_ptr<int[]> buffer_new (new int[size]);
  std::shared_ptr<int[]> buffer_new (new int[size]); 
  std::vector<int> buffer_new (size);  int* raw_access = buffer_new.data();

C ++ 14'ten ayrıca yazabilirsiniz

auto buffer_new = std::make_unique<int[]>(size);

bu daha hoş görünür ve ayırma başarısız olursa bellek sızıntısını önler. C ++ 20'den yapabildiğiniz kadarıyla

auto a = std::make_shared<int[]>(size);

bu benim için hala gcc 7.4.0 ile yazarken derlemiyor. Bu iki örnekte autosoldaki tür bildirimi yerine de kullanıyoruz . Her durumda, diziyi her zamanki gibi kullanın:

buffer_old[0] = buffer_new[0] = 17;

Bellek newiki katından sızıyor ve çöküyor deleteC ++, yıllardır başka dillere geçmenin argümantasyonunun "merkezi noktası" olan bir şeydir. Belki kaçınmak daha iyi.

new ve delete artık kullanılmıyor.

Yeni operatör tarafından oluşturulan nesneler referans ile aktarılabilir. Nesneler sil kullanılarak silinebilir.

yeni ve sil dilin temel özellikleridir. Bir nesnenin kalıcılığı, new ve delete kullanılarak yönetilebilir. Bunlar kesinlikle reddedilmeyecek.

- int dizisi [N] ifadesi, bir diziyi tanımlamanın bir yoludur. Dizi, ekteki kod bloğu kapsamında kullanılabilir. Bir nesnenin başka bir işleve nasıl aktarıldığı gibi geçirilemez.

İlk örneğin delete[]sonunda bir a gerekir , yoksa bellek sızıntısı olur.

İkinci örnek, C ++ tarafından desteklenmeyen değişken dizi uzunluğunu kullanır; bu sadece bir dizi uzunluğu sabit ekspresyonuna izin verir .

Bu durumda std::vector<>çözelti olarak kullanılması yararlı olur ; bir dizi üzerinde gerçekleştirebileceğiniz tüm eylemleri bir şablon sınıfına kaydırır.

Sözdizimi C ++ gibi görünüyor, ancak deyim eski Algol60'a benziyor. Bunun gibi kod blokları olması yaygındı:

read n;
begin
    integer array x[1:n];
    ... 
end;

Örnek şu şekilde yazılabilir:

while(T--) {
    int N;
    cin >> N;
    {
        int array[N];
        // Do something with 'array'
    }
}

Bunu şu anki dillerde kaçırıyorum;)