Diziler, işaretçiler ve işlevler için C sözdizimi neden bu şekilde tasarlandı?

Benzer soruları gördükten ve sorduktan sonra

int (*f)(int (*a)[5])C anlamı ne ?

ve insanların C sözdizimini anlamalarına yardımcı olacak bir program yaptıklarını görerek bile , yardım edemem ama merak ediyorum:

C sözdizimi neden bu şekilde tasarlandı?

Örneğin, işaretçiler tasarlıyor olsaydım, "işaretçiyi 10 öğeli işaretçi dizisine" çevirirdim

int*[10]* p;

ve değil

int* (*p)[10];

çoğu insanın aynı fikirde olduğunu düşünürüm.

Merak ediyorum, neden sezgisel olmayan sözdizimi? Sözdiziminin çözdüğü (belki de belirsizliği olan) belirli bir sorun var mıydı?

Tarihini anlamam iki ana noktaya dayanıyor olması ...

İlk olarak, dil yazarları sözdizimini tip merkezli değil, değişken merkezli yapmayı tercih ettiler. Bu da onların beyanı bakmak için bir programcı istedi ve düşünmek ise, "Ben deyim yazarsanız *func(arg), bu bir neden olacak int; ben yazarsam *arg[N]ben bir float olacak" "yerine funcbir işlev alarak bir gösterici olmalıdır bu ve dönen o ".

Vikipedi'de C girişi iddia:

Ritchie'nin fikri, tanımlayıcıları kullanımlarına benzeyen bağlamlarda beyan etmekti: "beyanname kullanımı yansıtır".

... ne yazık ki, sizin için genişletilmiş teklifi bulmak için elimde olmak zorunda değil.

İkincisi, keyfi dolaylı düzeylerle uğraşırken tutarlı bir beyan sözdizimi bulmak gerçekten, gerçekten zordur. Örneğiniz, orada yarasa düşündüğünüz türü ifade etmek için iyi çalışabilir, ancak bu tür bir diziye bir işaretçi alan ve başka bazı iğrenç karmaşa döndüren bir işleve ölçeklenir mi? (Belki öyle, ama kontrol ettin mi? Kanıtlayabilir misin? ).

Unutmayın, C'nin başarısı, derleyicilerin birçok farklı platform için yazılmasından kaynaklanmaktadır ve bu nedenle derleyicilerin yazılmasını kolaylaştırmak için bir dereceye kadar okunabilirliği göz ardı etmek daha iyi olabilirdi.

Bunu söyledikten sonra ben dil grameri veya derleyici yazımı konusunda uzman değilim. Ama bilinecek çok şey olduğunu biliyorum;)

C dilinin birçok tuhaflığı, bilgisayarların tasarlanırken çalışma şekli ile açıklanabilir. Çok sınırlı miktarda depolama belleği vardı, bu nedenle kaynak kodu dosyalarının boyutunu en aza indirmek çok önemliydi . 70'lerde ve 80'lerde programlama pratiği, kaynak kodun mümkün olduğunca az karakter içerdiğinden ve tercihen aşırı kaynak kodu yorumları olmadığından emin olmaktı.

Bu, elbette bugün sabit disklerde neredeyse sınırsız depolama alanı ile saçma. Ancak C'nin bu kadar tuhaf bir sözdizimine sahip olmasının nedeninin bir parçası.

Özellikle dizi işaretçileriyle ilgili olarak, ikinci örneğiniz int (*p)[10];(evet sözdizimi çok kafa karıştırıcı) olmalıdır. Belki de "on dizi dizisine int işaretçi" olarak okurdum ... bu biraz mantıklı. Parantez için değilse, derleyici bunu on işaretli bir dizi olarak yorumlayacak ve bu da bildirime tamamen farklı bir anlam verecektir.

Dizi işaretçileri ve işlev işaretleyicilerinin her ikisi de C'de oldukça belirsiz bir sözdizimine sahip olduğundan, yapılacak mantıklı şey tuhaflığı tanımlamaktır. Belki de şöyle:

Belirsiz örnek:

int func (int (*arr_ptr)[10])
{
  return 0;
}

int main()
{
  int array[10];
  int (*arr_ptr)[10]  = &array;
  int (*func_ptr)(int(*)[10]) = &func;

  func_ptr(arr_ptr);
}

Belirsiz, eşdeğer örnek:

typedef int array_t[10];
typedef int (*funcptr_t)(array_t*);


int func (array_t* arr_ptr)
{
  return 0;
}

int main()
{
  int        array[10];
  array_t*   arr_ptr  = &array; /* non-obscure array pointer */
  funcptr_t  func_ptr = &func;  /* non-obscure function pointer */

  func_ptr(arr_ptr);
}

İşlev işaretçileri dizileriyle uğraşıyorsanız, işler daha da belirsizleşebilir. Ya da hepsinden en belirsiz olanı: işlev işaretçileri döndüren işlevler (hafif kullanışlı). Bu tür şeyler için typedefs kullanmazsanız, çabucak delirirsiniz.

Oldukça basit: int *paraçlar *pbir int; int a[5]bu a[i]bir int anlamına gelir .

int (*f)(int (*a)[5])

Bu *fbir işlev, *abeş tamsayıdan oluşan bir dizidir, yani beş tamsayıdan oluşan bir diziye fbir işaretçi alan ve int döndüren bir işlevdir. Bununla birlikte, C'de bir diziye bir işaretçi geçirmek yararlı değildir.

C bildirimleri çok nadiren karmaşık hale gelir.

Ayrıca, typedefs kullanarak açıklığa kavuşabilirsiniz:

typedef int vec5[5];
int (*f)(vec5 *a);

* [] Değişkenine bağlı işleçler olarak düşünmeniz gerektiğini düşünüyorum. * bir değişkenden önce, [] sonra yazılır.

Şimdi tür ifadesini okuyalım

int* (*p)[10];

En içteki eleman p'dir, bu nedenle bir değişkendir,

p

şu anlama gelir: p bir değişkendir.

Değişken * olmadan önce, * operatörü her zaman atıfta bulunduğu ifadeden önce konur, bu nedenle,

(*p)

şu anlama gelir: p değişkeni bir işaretçidir. () Olmadan sağdaki [] operatörü daha yüksek önceliğe sahip olurdu, yani

**p[]

olarak ayrıştırılır

*(*(p[]))

Bir sonraki adım []: başka () olmadığı için, [] dıştan * daha yüksek önceliğe sahiptir, bu nedenle

(*p)[]

şu anlama gelir: (p değişkeni bir göstericidir) bir diziye. Sonra ikincimiz var *:

* (*p)[]

şu anlama gelir: ((değişken p bir göstericidir) bir diziye) işaretçiler

Son olarak, en düşük önceliğe sahip olan int işlecine (tür adı) sahipsiniz:

int* (*p)[]

şu anlama gelir: (((p değişkeni bir dizi) işaretçi)) tamsayı.

Bu nedenle, tüm sistem operatörlerle tip ifadelerine dayanmaktadır ve her operatörün kendi öncelik kuralları vardır. Bu çok karmaşık tiplerin tanımlanmasına izin verir.

Düşünmeye başladığınızda çok zor değil ve C hiç bu kadar kolay bir dil olmadı. Ve int*[10]* pgerçekten bundan daha kolay değil int* (*p)[10] Ve ne tür bir k olurdu?int*[10]* p, k;