C dizileri neden uzunluklarını izlemiyor?

Bir dizinin uzunluğunu bir dizinin içindeyken açıkça depolamamanın arkasındaki neden Cneydi?

Gördüğüm gibi, bunu yapmanın çok zor nedenleri var ama standardı desteklemiyor (C89). Örneğin:

1. Tamponda uzunluğun mevcut olması, tamponun taşmasını önleyebilir.
2. Bir Java stili arr.lengthhem açıktır hem de programcının intbirkaç dizi ile ilgileniyorsa yığın üzerinde birçok s bulundurma zorunluluğunu önler
3. Fonksiyon parametreleri daha uyumlu hale gelir.

Ancak, belki de en motive edici sebep, bence, genellikle, uzunluğunu muhafaza etmeden yer kazanmamasıdır. Dizilerin çoğu kullanımının dinamik tahsisat içerdiğini söylemeye teşebbüs ediyorum. Doğru, insanların yığında tahsis edilen bir diziyi kullandığı bazı durumlar olabilir, ancak bu yalnızca bir işlev çağrısı * olabilir - yığın 4 veya 8 bayt fazlalık işleyebilir.

Yığın yöneticisi, dinamik olarak tahsis edilen dizinin kullandığı boş blok büyüklüğünü yine de izlemek zorunda olduğundan, neden bu bilgiyi kullanılabilir kılmayalım (ve derleme zamanında kontrol edilen ek kuralı ekleyelim, bir tane uzunluğa kadar uzunluğu değiştiremez) kendini ayağından vurmak gibi).

Diğer tarafta düşünebildiğim tek şey, hiçbir uzunluk izlemenin derleyicileri daha basit hale getirmemiş olabileceği , ancak bu kadar basit hale getiremeyeceğidir .

* Teknik olarak, otomatik depolama dizisine sahip bir dizi özyinelemeli işlev yazılabilir ve bu (çok ayrıntılı) durumda, uzunluğu depolamak gerçekten de daha fazla alan kullanımıyla sonuçlanabilir.

Dizi uzunluğu statik bir özellik olduğundan C dizileri uzunluklarını izler:

int xs[42];  /* a 42-element array */

Bu uzunluğu genellikle sorgulayamazsınız, ancak yine de statik olması gerekmemek zorunda değilsiniz - sadece XS_LENGTHuzunluk için bir makro belirtin ve bitirdiniz.

Daha önemli olan konu, C dizilerinin, örneğin bir işleve geçildiğinde, işaretçilere dolaylı olarak indirgenmesidir. Bu mantıklı geliyor ve bazı düşük seviyeli numaralara izin veriyor, ancak dizinin uzunluğu hakkındaki bilgileri kaybediyor. Bu nedenle, daha iyi bir soru, C'nin işaretçilere bu dolaylı indirgeme ile neden tasarlandığıdır.

Diğer bir husus, işaretçilerin, bellek adresinin kendisinden başka bir depolamaya ihtiyaç duymamasıdır. C işaretçilere tamsayılar, diğer işaretçilere işaretçiler koymamıza ve işaretçileri dizilermiş gibi işlememize olanak tanır. Bunu yaparken, C dizi uzunluğunu varoluş için üretecek kadar delice değil, ama Örümcek Adam sloganına güveniyor gibi görünüyor: büyük güçle programcı uzunlukları ve taşmaları takip etme sorumluluğunu üstlenecek.

Bunların çoğu, o sırada mevcut bilgisayarlarla ilgiliydi. Derlenmiş programın sınırlı bir kaynak bilgisayarında çalışması gerekmekle kalmadı, belki de daha önemlisi, derleyicinin bu makinelerde çalışması gerekiyordu. Thompson C geliştirdiği sırada, 8k RAM ile bir PDP-7 kullanıyordu. Gerçek makine kodunda ani bir analogu bulunmayan karmaşık dil özellikleri dile dahil edilmedi.

C'nin geçmişini dikkatlice okuduğunuzda , yukarıdakileri daha iyi anlarsınız, ancak bu tamamen onların sahip olduğu makine kısıtlamalarının sonucu değildi:

Dahası, dil (C) önemli kavramları tanımlamak için önemli bir güç göstermektedir; örneğin, uzunluğu çalışma zamanında değişen vektörler, yalnızca birkaç temel kural ve kuralla. ... C'nin yaklaşımını neredeyse iki eşzamanlı dilin Algol 68 ve Pascal [Jensen 74] ile karşılaştırması ilginçtir. Algol 68'deki diziler ya sabit sınırlara sahiptir ya da “esnektir:” esnek dizileri barındırmak için hem dil tanımında hem de derleyicilerde kayda değer bir mekanizmaya ihtiyaç duyulur (ve tüm derleyiciler bunları tam olarak uygulamaz). diziler ve dizgiler ve bu sınırlayıcı oldu [Kernighan 81].

C dizileri doğal olarak daha güçlüdür. Onlara sınır eklemek, programcının ne için kullanabileceğini sınırlar. Bu kısıtlamalar, programcılar için faydalı olabilir, ancak zorunlu olarak da sınırlayıcı olabilir.

C'nin yaratıldığı güne geri dönersek, ne kadar kısa bir israf olursa olsun, her dize için fazladan 4 baytlık alan var!

Başka bir sorun var - C'nin nesne yönelimli olmadığını unutmayın, bu nedenle tüm dizelerin uzunluğunu öneklendirirseniz, bunun bir derleyici gerçek türü olarak tanımlanması gerekir char*. Özel bir tür olsaydı, bir dizeyi sabit bir dizeyle karşılaştıramazdınız, yani:

String x = "hello";
if (strcmp(x, "hello") == 0) 
  exit;

bu statik dizgiyi bir String'e dönüştürmek için özel derleyici ayrıntılarına sahip olmalı veya uzunluk önekini dikkate almak için farklı string işlevlerine sahip olmalıydı.

Sonuçta sanırım, sadece Pascal demenin aksine uzunluk-öneki yöntemini seçmediler.

C'de, bir dizinin bitişik herhangi bir alt kümesi de bir dizidir ve bu şekilde çalıştırılabilir. Bu hem okuma hem de yazma işlemleri için geçerlidir. Boyut açıkça depolanırsa bu özellik geçerli olmaz.

Dizileri uzunlukları ile etiketlemenin en büyük sorunu, bu uzunluğu depolamak için gereken alan ve ne şekilde depolanması gerektiği sorusudur (kısa diziler için bir ekstra bayt kullanmak genellikle sakıncalı olmaz, dördü kullanmak olmaz) uzun diziler için ekstra bayt, ancak kısa diziler için bile dört bayt kullanmak olabilir). Daha büyük bir problem ise aşağıdaki gibi bir kod verilmesidir:

void ClearTwoElements(int *ptr)
{
  ptr[-2] = 0;
  ptr[2] = 0;
}
void blah(void)
{
  static int foo[10] = {1,2,3,4,5,6,7,8,9,10};
  ClearTwoElements(foo+2);
  ClearTwoElements(foo+7);
  ClearTwoElements(foo+1);
  ClearTwoElements(foo+8);
}

bu kodun ilk çağrıyı ClearTwoElementskabul edip ikincisini reddetmesinin tek yolu, hangi ClearTwoElementsdurumda olduğunu foobilmekle birlikte, her durumda dizinin bir bölümüne referans aldığını bilmek için yeterli bilgiyi elde etmek için yöntem olacaktır . Bu genellikle işaretçi parametrelerinin geçme maliyetini iki katına çıkarır. Ayrıca, her bir dizi bir işaretçi ile en sondan önce bir adrese öncülük etmişse (doğrulama için en verimli format), bunun için optimize edilmiş kod ClearTwoElementsşöyle bir şey olabilir:

void ClearTwoElements(int *ptr)
{
  int* array_end = ARRAY_END(ptr);
  if ((array_end - ARRAY_BASE(ptr)) < 10 ||
      (ARRAY_BASE(ptr)+4) <= ADDRESS(ptr) ||          
      (array_end - 4) < ADDRESS(ptr)))
    trap();
  *(ADDRESS(ptr) - 4) = 0;
  *(ADDRESS(ptr) + 4) = 0;
}

Genel olarak, bir yöntem arayan kişinin, dizinin başlangıcına veya son öğenin bir yönteme meşru bir şekilde imleci geçebileceğini unutmayın; ancak yöntem, içeri aktarılan dizinin dışına çıkan öğelere erişmeye çalışırsa, bu işaretçiler herhangi bir soruna neden olur. Sonuç olarak, çağrılan bir yöntemin önce dizinin, bağımsız değişkenlerini doğrulamak için işaretçi aritmetiğinin kendisinin sınırları dışına çıkmayacağına ve ardından değişkenleri doğrulamak için bazı işaretçi hesaplamaları yapmasına yetecek kadar büyük olmasını sağlamak zorunda kalacaktı. Böyle bir onaylamada harcanan zaman muhtemelen gerçek bir iş yapmak için harcanan maliyeti aşacaktır. Dahası, yöntem yazılmış ve çağrılmışsa büyük olasılıkla daha verimli olabilir:

void ClearTwoElements(int arr[], int index)
{
  arr[index-2] = 0;
  arr[index+2] = 0;
}
void blah(void)
{
  static int foo[10] = {1,2,3,4,5,6,7,8,9,10};
  ClearTwoElements(foo,2);
  ClearTwoElements(foo,7);
  ClearTwoElements(foo,1);
  ClearTwoElements(foo,8);
}

Bir nesneyi tanımlamak için bir şeyle bir parçasını tanımlamak için bir şey birleştiren bir tür kavramı iyi bir tanesidir. Bununla birlikte, bir C tarzı işaretçi daha hızlıdır, ancak doğrulama yapmak gerekli değilse.

C ve diğer birçok 3. nesil dil ile farkında olduğum tüm yeni diller arasındaki temel farklardan biri, C'nin programcı için hayatı kolaylaştıracak veya daha güvenli hale getirecek şekilde tasarlanmamış olmasıdır. Programcının ne yaptığını bildiği ve tam olarak ve sadece bunu yapmak istediği beklentisi ile tasarlandı. “Perdenin arkasında” hiçbir şey yapmaz, bu yüzden herhangi bir sürprizle karşılaşmazsınız. Derleyici düzeyinde en iyi duruma getirme bile isteğe bağlıdır (bir Microsoft derleyici kullanmadığınız sürece).

Bir programcının kodlarını kontrol ederek sınırları yazmak istiyorsa, C bunu yapmayı basitleştirir, ancak programcının alan, karmaşıklık ve performans açısından ilgili fiyatı ödemesi gerekir. Uzun yıllardır öfkeyle kullanmamış olmama rağmen, programlama öğretirken kısıt temelli karar verme kavramını aşmak için kullanıyorum. Temel olarak, bu istediğiniz bir şeyi yapmayı seçebileceğiniz anlamına gelir, ancak yaptığınız her kararın farkında olmanız gereken bir bedeli vardır. Başkalarına programlarının ne yapmasını istediğinizi söylemeye başladığınızda bu daha da önemli hale gelir.

Kısa cevap:

C düşük seviyeli bir programlama dili olduğundan, bu sorunlara kendiniz bakmanızı bekler, ancak bu tam olarak nasıl uyguladığınıza daha fazla esneklik katar .

C bir uzunluk ile başlatılan bir dizi derleme zamanı kavramına sahiptir, ancak çalışma zamanında her şey basit bir şekilde verinin başlangıcına tek bir işaretçi olarak depolanır. Dizi uzunluğunu, dizi ile birlikte bir işleve geçirmek istiyorsanız, kendiniz yapın:

retval = my_func(my_array, my_array_length);

Veya işaretçi ve uzunlukta bir yapı veya başka bir çözüm kullanabilirsiniz.

Daha yüksek seviyeli bir dil, bunu dizi türünün bir parçası olarak sizin için yapar. C'de bunu kendin yapma sorumluluğu, aynı zamanda nasıl yapılacağını seçme esnekliği de verildi. Ve yazdığınız tüm kodlar zaten dizinin uzunluğunu biliyorsa, uzunluğu bir değişken olarak dolaştırmanız gerekmez.

Açık dezavantajı, işaretçiler olarak geçirilen dizileri denetleyen herhangi bir içsel sınır olmadan bazı tehlikeli kodlar yaratabileceğinizdir ancak bu, düşük seviye / sistem dillerinin ve verdikleri takasın niteliğidir.

Ekstra depolama sorunu bir sorun, ama bence küçük bir sorun. Sonuçta, çoğu zaman yine de uzunluğu izlemeniz gerekecek, ancak amon çoğu zaman statik olarak izlenebileceği konusunda iyi bir noktaya değindi.

Daha büyük bir sorun, uzunluğu nerede depolayacağınız ve ne kadar süre alacağınızdır. Her durumda işe yarayan tek bir yer yoktur. Verileri hemen önce sadece uzunluğu bellekte saklayabilirsiniz. Dizi hafızaya değil, UART tamponuna benzer bir şeyse?

Uzatmanın bırakılması, programcının uygun durum için kendi soyutlamalarını yaratmasına izin verir ve genel amaç için hazır birçok hazır kitaplık vardır. Bu soyutlama olmama neden gerçek soru kullanılan güvenlik duyarlı uygulamalarda?

Gönderen C Dil Gelişimi :

Görünüşe göre, yapılar makinedeki belleğe sezgisel bir şekilde eşleşmelidir, ancak bir dizi içeren bir yapıda, dizinin tabanını içeren işaretçiyi saklamak için iyi bir yer yoktu, ya da onu düzenlemek için uygun bir yol yoktu. başlatıldı. Örneğin, erken Unix sistemlerinin dizin girişleri C olarak tanımlanabilir.

struct {
    int inumber;
    char    name[14];
};

Yapının yalnızca soyut bir nesneyi karakterize etmekle kalmayıp, aynı zamanda bir dizinden okunabilecek bit koleksiyonunu tanımlamasını da istedim. Derleyici nameanlambilimin talep ettiği göstergeyi nereye gizleyebilir ? Yapılar daha soyut düşünülmüş olsa ve işaretçiler için yer bir şekilde gizlenebilse bile, karmaşık bir nesne tahsis ederken bu işaretleyicileri düzgün bir şekilde başlatmadaki teknik problemi nasıl çözebilirim?

Çözüm, tipik BCPL ve C tipi arasında evrimsel zincirde çok önemli bir sıçrama oluşturdu. İşaretçinin depoda gerçekleşmesini elimine etti ve bunun yerine, dizinin adı bir ifadede belirtildiğinde işaretleyicinin oluşturulmasına neden oldu. Bugünün C'sinde geçerli olan kural, dizi türündeki değerlerin, ifadelerde göründüğünde, diziyi oluşturan nesnelerin ilkine işaretçilere dönüştürülmesidir.

Bu pasaj, dizi ifadelerinin çoğu durumda işaretçilere neden çürümesine neden olur, ancak aynı sebep, dizi uzunluğunun neden dizinin kendisinde saklanmadığına da uygulanır; tür tanımı ile bellekteki gösterimi arasında bire bir eşleme yapmak istiyorsanız (Ritchie'nin yaptığı gibi), o zaman bu meta verileri depolamak için iyi bir yer yoktur.

Ayrıca, çok boyutlu dizileri düşünün; Her boyut için uzunluk meta verilerini nerede saklarsınız ki öyle bir şekilde diziyi geçmeye devam edersiniz

T *p = &a[0][0];

for ( size_t i = 0; i < rows; i++ )
  for ( size_t j = 0; j < cols; j++ )
    do_something_with( *p++ );

Soru, C'de diziler olduğunu varsayar. Yok. Dizi olarak adlandırılan şeyler, sürekli veri dizileri ve işaretçi aritmetik işlemleri için sadece sözdizimsel bir şekerdir.

Aşağıdaki kod, bazı karakterlerin src'den dst'ye, aslında karakter dizgisi olduğunu bilmeden int-boyutlu parçalarda kopyalar.

char src[] = "Hello, world";
char dst[1024];
int *my_array = src; /* What? Compiler warning, but the code is valid. */
int *other_array = dst;
int i;
for (i = 0; i <= sizeof(src)/sizeof(int); i++)
    other_array[i] = my_array[i]; /* Oh well, we've copied some extra bytes */
printf("%s\n", dst);

C neden bu kadar basitleştirilmiş, uygun dizileri yok? Bu yeni soruya doğru cevabı bilmiyorum. Ancak bazı insanlar genellikle C'nin (biraz) daha okunaklı ve taşınabilir bir montaj aracı olduğunu söyler.