C ++ 'da statik dizi ve dinamik dizi

C ++ 'da statik dizi ile dinamik dizi arasındaki fark nedir?

Sınıfım için bir atama yapmam gerekiyor ve statik dizileri değil, sadece dinamik dizileri kullanmamı söylüyor. Kitaba ve internete baktım, ama anlamıyor gibiyim.

Statiğin derleme zamanında ve dinamik olarak çalışma zamanında oluşturulduğunu düşündüm, ancak bunu bellek ayırma ile karıştırıyor olabilirim.

C ++ 'da statik dizi ve dinamik dizi arasındaki farkı açıklayabilir misiniz?

Yığın üzerinde yerel diziler oluşturulur ve otomatik depolama sürelerine sahiptir - belleği manuel olarak yönetmeniz gerekmez, ancak işlev sona erdiğinde yok edilirler. Mutlaka sabit bir boyuta sahipler:

int foo[10];

operator new[]Dinamik depolama süresine sahip olan diziler yığın üzerinde depolanır (teknik olarak "ücretsiz depo"). Herhangi bir boyuta sahip olabilirler, ancak yığın çerçevesinin bir parçası olmadıkları için bunları kendiniz ayırmanız ve serbest bırakmanız gerekir:

int* foo = new int[10];
delete[] foo;

static, C ve C ++ 'da bir anahtar kelimedir, bu nedenle genel bir tanımlayıcı terimden ziyade, statik bir değişkene veya diziye uygulandığında çok özel bir anlama sahiptir. Karışıklığı birleştirmek için, ayrı bağlamlarda üç farklı anlamı vardır. Bu nedenle, statik bir dizi sabit veya dinamik olabilir.

Açıklamama izin ver:

İlki C ++ 'ya özgüdür:

• Statik sınıf üyesi, yapıcıyla başlatılmayan veya yıkıcıyla silinmeyen bir değerdir. Bu, üyenin başka bir şekilde başlatılması ve bakımı yapılması gerektiği anlamına gelir. statik üye, null olarak başlatılan işaretçiler olabilir ve daha sonra bir kurucu ilk çağrıldığında tahsis edilebilir. (Evet, bu statik ve dinamik olur)

İki tanesi C'den miras alınır:

• Bir işlev içinde, statik değişken, bellek konumu işlev çağrıları arasında korunan değişkendir. Yalnızca bir kez başlatıldığı ve işlev çağrıları arasında değerini koruduğu için statiktir (statik kullanımı bir işlevi evresel olmayan yapar, yani evreli olmayan)

• İşlevlerin dışında bildirilen statik değişkenler, yalnızca aynı modül içinden erişilebilen global değişkenlerdir (diğer # include'lerin olduğu kaynak kod dosyası)

Sormak istediğiniz soru (sanırım) dinamik diziler ile sabit veya derleme zamanı dizileri arasındaki farkın ne olduğudur. Bu daha kolay bir sorudur, derleme zamanı dizileri önceden belirlenir (program derlendiğinde) ve bir işlev yığını çerçevesinin parçasıdır. Ana işlev çalışmadan önce tahsis edilirler. dinamik diziler çalışma zamanında "new" anahtar sözcüğü (veya C'den malloc ailesi) ile tahsis edilir ve boyutları önceden bilinmemektedir. dinamik ayırmalar, program çalışmayı durdurana kadar otomatik olarak temizlenmez.

Sınıfınızda kullanılan anlambilimin kafa karıştırıcı olduğunu düşünüyorum. Muhtemelen "statik" ile kastedilen basitçe "sabit boyuttur" ve muhtemelen "dinamik" ile "değişken boyut" kastedilmektedir. Bu durumda, sabit boyutlu bir dizi şöyle görünebilir:

int x[10];

ve "dinamik" bir yapı, temeldeki depolamanın çalışma zamanında artırılmasına veya azaltılmasına izin veren herhangi bir yapı olabilir. Çoğu zaman, std::vectorC ++ standart kitaplığındaki sınıf yeterli olacaktır. Bunu şu şekilde kullanın:

std::vector<int> x(10); // this starts with 10 elements, but the vector can be resized.

std::vectorolan operator[]bir dizi olarak aynı anlamda kullanabilirsiniz, böylece tanımlanmış.

Statik dizilere derleme zamanında bellek ayrılır ve bellek yığın üzerinde ayrılır. Oysa dinamik dizilere çalışma zamanında bellek tahsis edilir ve bellek öbekten ayrılır.

int arr[] = { 1, 3, 4 }; // static integer array.   
int* arr = new int[3]; // dynamic integer array.

Terimlerin ne anlama geldiğine dair net tanımlara sahip olmak önemlidir. Ne yazık ki, statik ve dinamik dizilerin ne anlama geldiğine dair birden fazla tanım var gibi görünüyor.

Statik değişkenler , statik bellek tahsisi kullanılarak tanımlanan değişkenlerdir . Bu, C / C ++ 'dan bağımsız genel bir kavramdır. C / C ++ 'da aşağıdaki gibi global, dosya veya yerel kapsamda statik değişkenler oluşturabiliriz:

int x[10]; //static array with global scope
static int y[10]; //static array with file scope
foo() {
    static int z[10]; //static array with local scope

Otomatik değişkenler genellikle yığın tabanlı bellek tahsisi kullanılarak uygulanır . C / C ++ 'da şu şekilde otomatik bir dizi oluşturulabilir:

foo() {
    int w[10]; //automatic array

Ne bu diziler, x, y, zve wortak noktası bunların her biri için boyut sabittir ve derleme zamanında tanımlanan olmasıdır.

Otomatik dizi ile statik dizi arasındaki farkı anlamanın önemli olmasının nedenlerinden biri, statik depolamanın genellikle bir nesne dosyasının veri bölümünde (veya BSS bölümünde ) uygulanması ve derleyicinin dizilere erişmek için mutlak adresler kullanabilmesidir. yığın tabanlı depolamayla bu imkansızdır.

Genellikle dinamik dizi ile kastedilen, yeniden boyutlandırılabilen değil, çalışma zamanında belirlenen sabit bir boyuta sahip dinamik bellek ayırma kullanılarak uygulanan bir dizidir . C ++ 'da bu, newoperatör kullanılarak yapılır .

foo() {
   int *d = new int[n]; //dynamically allocated array with size n     

Ancak, aşağıdakileri kullanarak çalışma zamanında tanımlanan bir düzeltme boyutuna sahip otomatik bir dizi oluşturmak mümkündür alloca:

foo() {
    int *s = (int*)alloca(n*sizeof(int))

Gerçek bir dinamik dizi std::vectoriçin C ++ 'da olduğu gibi (veya C'de değişken uzunluklu bir dizi ) kullanılmalıdır.

OP'nin sorusundaki görev için ne ifade edildi? Sanırım, istenen şeyin statik veya otomatik bir dizi değil, newoperatörü kullanarak dinamik bellek tahsisi veya örn std::vector.

Bence bu bağlamda, boyutun sabit olması anlamında statik olduğu anlamına geliyor. Std :: vector kullanın. Resize () işlevi vardır.

Boyutun kullanıcı tarafından çalışma zamanında ayarlandığı, ancak daha sonra sabitlendiği bir sözde dinamik diziniz olabilir.

int size;
cin >> size;
int dynamicArray[size];

Statik Dizi :

1. Statik dizilere derleme zamanında bellek ayrılır.
2. Boyut sabittir.
3. Yığın bellek alanında bulunur.
4. Örneğin. : int dizi [10]; // boyut 10 dizisi

Dinamik Dizi:

1. Bellek, çalışma zamanında tahsis edilir.
2. Boyut sabit değil.
3. Yığın bellek alanında bulunur.
4. Örneğin. : int * dizi = new int [10];

Evet, statik dizi, çalışma zamanında dinamik dizinin oluşturulduğu derleme zamanında yaratılır. Fark, bellek konumlarıyla ilgili olduğunda, statik yığın üzerinde bulunur ve dinamik yığın üzerinde oluşturulur. Yığın üzerinde bulunan her şey, .net çerçevesinde olduğu gibi çöp toplayıcı mevcut olana kadar bellek yönetimine ihtiyaç duyar, aksi takdirde bellek sızıntısı riski vardır.

Statik dizi: Verimlilik. Dinamik ayırma veya serbest bırakmaya gerek yoktur.

C, C ++ 'da statik değiştirici içeren işlevde bildirilen diziler statiktir. Örnek: statik int foo [5];

dizinin yan tarafındaki elemanların verilmesiyle oluşan statik düzen

dizinin yan tarafındaki öğeleri vermeden dinamik aralık

misal:

     char a[10]; //static array
       char a[];  //dynamic array