Yıldız işareti neden türden sonra değil, değişken adından önce?

Çoğu C programcısı neden bu gibi değişkenleri adlandırır:

int *myVariable;

bunun yerine:

int* myVariable;

Her ikisi de geçerlidir. Bana öyle geliyor ki yıldız işareti değişken adının bir parçası değil, türün bir parçası. Bu mantığı kimse açıklayabilir mi?

Bunlar TAMAMEN eşdeğerdir. Ancak,

int *myVariable, myVariable2;

Bu myVariable tipi olduğu aşikardır int * myVariable2 tipi varken, int . İçinde

int* myVariable, myVariable2;

her iki tipi olduğu aşikar görünebilir int * , ancak bu doğru değildir myVariable2tipi vardır int .

Bu nedenle, ilk programlama stili daha sezgiseldir.

Eğer ona başka bir şekilde bakarsanız, bir anlam ifade eden *myVariabletiptedir int.

Çünkü bu satırdaki *, değişkene türden daha yakından bağlanır:

int* varA, varB; // This is misleading

@Lundin'in aşağıda belirttiği gibi, const düşünülecek daha fazla incelik ekler. Asla muğlak olmayan, her satırda bir değişken bildirerek bunu tamamen kaldırabilirsiniz:

int* varA;
int varB;

Açık kod ve özlü kod arasındaki dengeyi bulmak zordur - bir düzine gereksiz satır int a;da iyi değildir. Yine de, varsayılan olarak satır başına bir bildirime ve daha sonra kodu birleştirme konusunda endişeleniyorum.

Burada şimdiye kadar kimsenin bahsetmediği bir şey, bu yıldız işaretinin aslında C'deki " dereference operatörü " olmasıdır.

*a = 10;

Çizgi üstünde ben atamak istediğiniz anlamına gelmez 10kadar a, ben atamak istediğiniz anlamına gelir 10ne olursa olsun hafıza yeri için aiçin puan. Ve hiç kimsenin yazdığını görmedim

* a = 10;

senin varmi? Yani KQUEUE operatör hemen hemen her zaman bir boşluk olmadan yazılır. Bu muhtemelen onu birden çok satırda kesilmiş bir çarpmadan ayırt etmektir:

x = a * b * c * d
  * e * f * g;

İşte *eyanıltıcı olurdu, değil mi?

Tamam, şimdi aşağıdaki satır aslında ne anlama geliyor:

int *a;

Çoğu insan şöyle der:

Bunun anlamı abir intdeğerin göstergesidir .

Bu teknik olarak doğrudur, çoğu insan onu bu şekilde görmeyi / okumayı sever ve modern C standartlarının bunu nasıl tanımlayacağını (C dilinin kendisinin tüm ANSI ve ISO standartlarından önce geldiğini unutmayın). Ama ona bakmanın tek yolu bu değil. Bu satırı aşağıdaki gibi de okuyabilirsiniz:

Şerefine edilmemiş değeri atürdür int.

Aslında bu bildirideki yıldız işareti, yerleşimini de açıklayan bir dereference operatörü olarak görülebilir. Ve bu abir işaretçi gerçekten hiç beyan edilmemiştir, gerçekte dereference yapabileceğiniz tek şeyin bir işaretçi olduğu gerçeğiyle örtülüdür.

C standardı, *operatör için sadece iki anlam tanımlar :

• dolaylı operatör
• çarpma operatörü

Ve dolaylı anlatım sadece tek bir anlamdır, bir işaretçiyi bildirmek için fazladan bir anlam yoktur, sadece dolaylı anlatım vardır, dereference işleminin yaptığı şey dolaylı bir erişim gerçekleştirir, dolayısıyla bunun gibi bir ifade içinde int *a;dolaylı bir erişimdir ( *araçlar dolaylı erişim) ve dolayısıyla yukarıdaki ikinci ifade standarda birincisinden çok daha yakındır.

Burada bir kol çıkmak ve söylemek için gidiyorum bu soruya basit bir cevap var yıldız adının yanındaki dönmeli olan değişken bildirimleri ve parametre ve dönüş türleri için hem: int *myVariable;. Nedenini anlamak için, C'deki diğer sembol türlerini nasıl bildirdiğinize bakın:

int my_function(int arg); bir işlev için;

float my_array[3] bir dizi için.

Bildirim olarak adlandırılan genel desen, bir sembolün türünün addan önceki bölüme ve adın etrafındaki bölümlere ayrılması ve adın etrafındaki bu bölümlerin, soldaki türün değeri:

int a_return_value = my_function(729);

float an_element = my_array[2];

ve: int copy_of_value = *myVariable;.

C ++, başvuruları olan çalışmalarda bir anahtar atar, çünkü başvuruları kullandığınız noktadaki sözdizimi değer türleriyle aynıdır, bu nedenle C ++ 'nın C'ye farklı bir yaklaşım aldığını iddia edebilirsiniz. işaretçiler durumunda C'nin davranışı, bu nedenle referanslar gerçekten bu açıdan garip olanıdır.

Bu sadece bir tercih meselesi.

Kodu okuduğunuzda, değişkenler ve işaretçiler arasında ayrım yapmak ikinci durumda daha kolaydır, ancak ortak bir türün hem değişkenlerini hem de işaretleyicilerini tek bir satıra koyarsanız karışıklığa yol açabilir (ki bu genellikle proje yönergeleri tarafından caydırılır, çünkü okunabilirliği azaltır).

İşaretçileri tür adının yanında karşılık gelen işaretiyle bildirmeyi tercih ederim

int* pMyPointer;

Büyük bir guru bir keresinde "Derleyicinin yolunu okuyun, yapmanız gerekir" dedi.

http://www.drdobbs.com/conversationsa-midsummer-nights-madness/184403835

Bu, const yerleştirme konusunda yapıldı, ancak aynı kural burada geçerlidir.

Derleyici bunu şöyle okur:

int (*a);

olarak değil:

(int*) a;

Yıldızı değişkenin yanına yerleştirme alışkanlığına sahip olursanız, bildirimlerinizin okunmasını kolaylaştıracaktır. Aynı zamanda gözenekleri de önler:

int* a[10];

-- Düzenle --

Ben o kadar çözümlenen oluyor derken ne demek istediğimi tam olarak açıklamak için int (*a)araçlar o, *daha sıkı bağlanan aöyle daha hiç int, çok şekilde ifade o 4 + 3 * 7 3daha sıkı bağlanarak onu 7yok daha hiç 4yüksek öncelik nedeniyle *.

Ascii sanatı için özür dilerken, AST'nin ayrıştırma özeti int *akabaca şöyle görünür:

      Declaration
      /         \
     /           \
Declaration-      Init-
Secifiers       Declarator-
    |             List
    |               |
    |              ...
  "int"             |
                Declarator
                /       \
               /        ...
           Pointer        \
              |        Identifier
              |            |
             "*"           |
                          "a"

Açıkça gösterildiği gibi, ortak ataları olduğu *için daha sıkı bağlanırken a, ortak bir ata bulmak Declaratoriçin ağacın her tarafına gitmeniz gerekir .Declarationint

Çünkü aşağıdaki gibi beyanlarınız olduğunda daha mantıklı:

int *a, *b;

Bir satırda birden fazla işaretçi bildirmek için, int* a, * b;daha sezgisel olarak bir tamsayıyı işaretçi olarak "a" olarak bildiren ve aynı şekilde "b" bildirirken stilleri karıştırmayan tercih ederim . Birisinin dediği gibi, zaten aynı ifadede iki farklı tip beyan etmem.

Tercih edenler int* x;, kodlarını türün solda ve tanımlayıcının (adın) sağda olduğu kurgusal bir dünyaya zorlamaya çalışıyorlar.

"Kurgusal" diyorum çünkü:

C ve C ++ 'da, genel durumda, bildirilen tanımlayıcı tip bilgisi ile çevrelenir.

Bu çılgınca gelebilir, ama bunun gerçek olduğunu biliyorsun. İşte bazı örnekler:

• int main(int argc, char *argv[])" mainbir intve işaretçiler dizisini charalıp döndüren bir işlevdir int." Başka bir deyişle, tür bilgilerinin çoğu sağdadır. Bazı insanlar fonksiyon bildirimlerinin dikkate alınmadığını çünkü bir şekilde "özel" olduklarını düşünürler. Tamam, bir değişkeni deneyelim.

• void (*fn)(int)anlamına gelir fn, bir işlevi alan intve hiçbir şey döndürmeyen bir işlevin işaretçisidir .

• int a[10]'a' değerini 10 intsaniyelik bir dizi olarak bildirir .

• pixel bitmap[height][width].

• Açıkçası, benim açımdan yapmak için sağda çok fazla tip bilgisi olan kiraz örneklerini aldım. Türün çoğunun - olmasa da - solda olduğu gibi birçok beyan var struct { int x; int y; } center.

Bu beyan sözdizimi, K & R'nin kullanımı yansıtan beyanlara sahip olma arzusundan doğmuştur. Basit bildirimleri okumak sezgiseldir ve daha karmaşık olanları okumak, sağ-sol-sağ kuralını öğrenerek yönetilebilir (bazen spiral kuralı veya sadece sağ-sol kuralı olarak adlandırın).

C, birçok C programcısının bu stili benimsemesi ve basit bildirimler yazması kadar basittir int *p.

C ++ 'da sözdizimi biraz daha karmaşık hale geldi (sınıflar, referanslar, şablonlar, numaralandırma sınıfları ile) ve bu karmaşıklığa bir tepki olarak, birçok bildirimde türü tanımlayıcıdan ayırmak için daha fazla çaba göreceksiniz. Başka bir deyişle, int* pbüyük bir C ++ kodu alanına göz atarsanız daha fazla stil bildirimi görebilirsiniz .

Her iki dil olarak, olabilir , her zaman sol tarafındaki tip değişken tarafından bildirimleri (1) asla aynı açıklamada birden çok değişkeni bildirerek, ve (2) yararlanarak typedef, ironik, takma koymak s (veya takma bildirimleri, türlerin solundaki tanımlayıcılar). Örneğin:

typedef int array_of_10_ints[10];
array_of_10_ints a;

Zaten CP'de benzer bir soruya cevap verdim ve kimse bundan bahsetmediği için, burada da C'nin serbest biçimli bir dil olduğunu , ayrıştırıcıyı her tokenden ayırt edebilirken, hangi stili seçerseniz seçin. C'nin bu özelliği C gizleme yarışması adı verilen çok özel bir yarışmaya yol açar .

Bu konudaki argümanların çoğu açık özneldir ve "yıldız değişken adına bağlanır" hakkındaki argüman naiftir. İşte sadece fikir olmayan birkaç argüman:

Unutulmuş işaretçi türü niteleyicileri

Resmi olarak, "yıldız" ne tipe ne de değişken isme ait değildir, işaretçi adı verilen kendi gramer öğesinin bir parçasıdır . Resmi C sözdizimi (ISO 9899: 2018):

(6.7) Beyan:
Beyanname belirteçleri init-declarator-list _opt ;

Burada beyan-belirteçleri tipi (ve depolama) içerir ve init-Bildiricisi listesi işaretçi ve değişken adını içerir. Bu bildirim listesi sözdizimini daha da inceleyip inceleyemeyeceğimizi görüyoruz:

(6.7.6) bildirici :
işaretçi _opt doğrudan bildirici
...
(6.7.6) işaretçi:
* tip-niteleyici-listesi _opt
* tip-niteleyici-listesi _opt işaretçisi

Bir bildirimin tüm bildirim olduğu durumda, bir doğrudan bildirici tanımlayıcıdır (değişken adı) ve bir işaretçi yıldızdır ve ardından işaretçinin kendisine ait isteğe bağlı bir tür niteleyici listesi gelir.

"Yıldız değişkene aittir" hakkındaki çeşitli stil argümanlarını tutarsız yapan şey, bu işaretçi türü niteleyicileri unutmuş olmalarıdır. int* const x, int *const xveya int*const x?

Düşünmek int *const a, b; , çeşitleri nelerdir ave b? Artık "yıldız değişkene ait" diye belli değil. Bunun yerine, kişi constait olduğu yeri düşünmeye başlayacaktır .

Yıldızın işaretçi türü niteleyicisine ait olduğu, ancak bunun ötesinde olmadığı konusunda sağlam bir argüman yapabilirsiniz.

İşaretçinin tür niteleyici listesi int *astili kullanan kişiler için sorunlara neden olabilir . Bir işaretçi kullananlar typedef(ki yapmamalıyız, çok kötü bir uygulama!) Ve "yıldız değişken isme aittir" diye düşünenler bu çok ince hatayı yazma eğilimindedir:

    /*** bad code, don't do this ***/
    typedef int *bad_idea_t; 
    ...
    void func (const bad_idea_t *foo);

Bu temiz bir şekilde derlenir. Şimdi kod const doğru yapılmış olduğunu düşünebilirsiniz. Öyle değil! Bu kod yanlışlıkla sahte bir sabit doğruluktur.

fooAslında türü int*const*- en dış işaretçi verilere değil, salt okunur yapıldı. Yani bu fonksiyonun içinde yapabiliriz**foo = n; ve arayandaki değişken değerini değiştirir.

Çünkü ifadede const bad_idea_t *foo, *buradaki değişken isme ait değildir! Sahte kod, bu parametre, bildirimi olarak okunacak olan const (bad_idea_t *) foove olmayan şekilde (const bad_idea_t) *foo. Yıldız, bu durumda gizli işaretçi türüne aittir - tür bir işaretçi ve sabit nitelikli bir işaretçi olarak yazılır *const.

Ama sonra yukarıdaki örnekte sorunun kökü, işaretçileri stilin typedefdeğil a'nın arkasına gizleme uygulamasıdır *.

Tek bir satırda birden çok değişkenin bildirilmesine ilişkin

Tek bir satırda birden fazla değişkenin bildirilmesi yaygın olarak kötü uygulama olarak kabul edilmektedir ¹⁾ . CERT-C güzelce şöyle özetliyor:

DCL04-Cı. Beyan başına birden fazla değişken bildirme

Sadece İngilizce okuma, ardından sağduyu kabul eder bir deklarasyon olmalıdır bir beyanı.

Değişkenlerin işaretçi olup olmadığı önemli değildir. Her değişkeni tek bir satırda bildirmek, kodu neredeyse her durumda daha net hale getirir.

Dolayısıyla programcının kafasının karışmasına ilişkin tartışma int* a, bkötü. Sorunun kökü, yerleşiminin değil, birden çok bildiricinin kullanılmasıdır *. Tarzdan bağımsız olarak, bunun yerine şunu yazmalısınız:

    int* a; // or int *a
    int b;

Başka bir sağlam ama öznel argüman ise int* a, türünün asorgulanmadanint* ve yıldızın tür niteleyicisine ait olduğu olabilir.

Ama temelde benim sonucum, burada yayınlanan argümanların çoğunun sadece öznel ve naif olduğu. Her iki stil için gerçekten geçerli bir argüman yapamazsınız - bu gerçekten öznel kişisel tercih meselesidir.

1) CERT-C DCL04-C .

Düşünmek

int *x = new int();

Bu,

int *x;
*x = new int();

Aslında şu anlama gelir

int *x;
x = new int();

Bu, int *xgösterimi bir şekilde tutarsız hale getirir .