Her zaman const int*, nasıl const int * constve int const *doğru bir şekilde kullanacağımı karıştırıyorum . Neler yapabileceğinizi ve yapamayacağınızı tanımlayan bir dizi kural var mı?

Görevler, işlevlere geçme vb. Bakımından tüm yapılacak ve yapılmayacak şeyleri bilmek istiyorum.

Geriye doğru okuyun ( Clockwise / Spiral Kural tarafından yönlendirildiği gibi ):

• int* - int işaretçisi
• int const * - int int işaretçisi
• int * const - int için const işaretçisi
• int const * const - const int için const işaretçisi

Şimdi ilk consttürün her iki tarafında olabilir yani:

• const int * == int const *
• const int * const == int const * const

Eğer gerçekten çıldırmak istiyorsanız, bunun gibi şeyler yapabilirsiniz:

• int ** - işaretçi int
• int ** const - int işaretçisine sabit işaretçi
• int * const * - int için sabit bir işaretçiye bir işaretçi
• int const ** - sabit bir işaretçiye bir işaretçi int
• int * const * const - int için bir sabit işaretçiye bir sabit işaretçi
• ...

Ve şu anlamlara dikkat ettiğimizden emin olmak için const:

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



int *const bar = &c;  // constant pointer to int 
                      // note, you actually need to set the pointer 
                      // here because you can't change it later ;)

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.           

foosabit bir tamsayının değişken göstergesidir. Bu, işaret ettiğiniz değeri değiştirmenizi sağlar, ancak işaret ettiğiniz değeri değiştirmez. Çoğu zaman bu, bir işaretçiye sahip olduğunuz C stili dizelerle görülür const char. Hangi dizeyi işaret ettiğinizi değiştirebilirsiniz ancak bu dizelerin içeriğini değiştiremezsiniz. Dizenin kendisi bir programın veri segmentindeyse ve değiştirilmemesi gerektiğinde bu önemlidir.

bardeğiştirilebilir bir değerin sabit veya sabit bir göstergesidir. Bu, ekstra sözdizimsel şekeri olmayan bir referans gibidir. Bu nedenle, T* constişaretçilere izin vermeniz gerekmediği sürece , genellikle bir işaretçi kullanacağınız bir referans kullanırsınız NULL.

Clockwise / Spiral Kuralı hakkında bilgi sahibi olmayanlar için: Değişkenin adından başlayın, saat yönünde (bu durumda, geriye doğru hareket ettirin) bir sonraki işaretçiye veya türe gidin . İfade bitene kadar tekrarlayın.

İşte bir demo:

Sanırım burada her şey zaten cevaplandı, ama sadece typedefs dikkat edin eklemek istiyorum ! Bunlar sadece metin değiştirme DEĞİLDİR.

Örneğin:

typedef char *ASTRING;
const ASTRING astring;

Türü astringolduğunu char * const, değil const char *. Bu, her zaman consttürün sağına koyma eğilimimin bir sebebidir ve asla başlangıçta değil.

Herkesin işaret ettiği gibi:

Ne arasındaki fark var const X* p, X* const pve const X* const p?

İşaretçi bildirimlerini sağdan sola okumalısınız.

• const X* p "p sabit olan bir X'i işaret eder" anlamına gelir: X nesnesi p ile değiştirilemez.

• X* const p "p, sabit olmayan bir X'in sabit göstergesidir": p işaretçisinin kendisini değiştiremezsiniz, ancak X nesnesini p ile değiştirebilirsiniz.

• const X* const p "p, sabit olan bir X'in sabit göstergesidir" anlamına gelir: p işaretçisinin kendisini değiştiremezsiniz veya X nesnesini p ile değiştiremezsiniz.

1. Sürekli referans:

   Sabit olan bir değişkene (burada int) başvuru. Değişkeni esas olarak referans olarak geçiririz, çünkü referanslar gerçek değerden daha küçüktür, ancak bir yan etkisi vardır ve bunun nedeni gerçek değişkenin bir takma adı olmasıdır. Takma adı tam erişimimizle yanlışlıkla ana değişkeni değiştirebiliriz, bu nedenle bu yan etkiyi önlemeyi sürekli hale getiririz.

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK

2. Sabit işaretçiler

   Sabit bir işaretçi bir değişkeni gösterdiğinde, başka bir değişkeni gösteremez.

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error

3. Sabit ile işaretçi

   Birinin işaret ettiği bir değişkenin değerini değiştiremediği bir işaretçi, sabite işaretçi olarak bilinir.

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error

4. Sabit bir sabite işaretçi

   Sabit bir sabit işaretçi, işaret ettiği adresi değiştiremeyen ve bu adreste tutulan değeri değiştiremeyen bir işaretçi.

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error

Genel kural, constanahtar kelimenin kendisinden önce gelen anahtar kelimeye uygulanmasıdır. İstisna, constaşağıdakilere bir başlangıç uygulanır.

• const int*ile aynıdır int const*ve "sabit int işaretçisi" anlamına gelir .
• const int* constaynıdır int const* constve aracı "sabit int sabit pointer" .

Düzenleme: Yapılacaklar ve Yapılmayacaklar için, eğer bu cevap yeterli değilse, ne istediğiniz konusunda daha kesin olabilir misiniz?

Bu soru, neden sorularımda bahsettiğim şekilde tür kimlik kabul edilebilir const sonra const olduğunu gibi şeyler yapmak istiyorum tam olarak gösterir ?

Kısacası, kuralı hatırlamanın en kolay yolunu "const" un geçerli olduğu şeyin peşinden gitmesi olduğunu düşünüyorum. Sorunuzda "int const *", int'in sabit olduğu anlamına gelirken, "int * const", işaretçinin sabit olduğu anlamına gelir.

Birisi ön tarafa koymaya karar verirse (örneğin: "const int *"), bu durumda özel bir istisna olarak, bundan sonraki şey için geçerlidir.

Birçok insan bu özel istisnayı kullanmayı sever çünkü daha hoş göründüğünü düşünürler. Bunu sevmiyorum, çünkü bu bir istisna ve bu yüzden işleri karıştırıyor.

Basit Kullanımı const .

En basit kullanım, adlandırılmış bir sabit bildirmektir. Bunu yapmak için, bir değişkeni sanki bir değişkenmiş gibi bildirir ancak constondan önce ekler . Kişi derhal kurucuda başlatmalıdır, çünkü elbette, değeri daha sonra değiştireceği için ayarlayamaz. Örneğin:

const int Constant1=96; 

yaratıcı olmayan bir tamsayı sabiti oluşturacak Constant196 değerine sahip .

Bu tür sabitler, programda kullanılan ancak program derlendikten sonra değiştirilmesi gerekmeyen parametreler için kullanışlıdır. C önişlemcisine göre programcılar için bir avantajı vardır#define komutuna göre , çünkü ana derleyiciye ulaşmadan önce sadece önişlemci tarafından program metninin yerine değil, derleyicinin kendisi tarafından anlaşılması ve kullanılması, bu nedenle hata mesajları çok daha yararlıdır.

constİşaretçilerle de çalışır, ancak işaretçinin veya neyi gösterdiğinin sabit olup olmadığını veya her ikisini birden belirlemeye dikkat etmek gerekir . Örneğin:

const int * Constant2 

Constant2sabit bir tamsayıya değişken gösterici olduğunu bildirir ve:

int const * Constant2

aynı şeyi yapan alternatif bir sözdizimidir.

int * const Constant3

Constant3değişken bir tamsayının sabit göstergesini bildirir ve

int const * const Constant4

beyan Constant4sabit bir tamsayı sürekli işaretçidir. Temel olarak 'const' hemen solundaki her şey için geçerlidir (orada hiçbir şey yoksa, bu durumda hemen sağ olan her şey için geçerlidir).

ref: http://duramecho.com/ComputerInformation/WhyHowCppConst.html

C ++ Guru Scott Meyers'ın bu kitabına rastlayana kadar seninle aynı şüphem vardı . Kullanımı hakkında ayrıntılı olarak konuştuğu bu kitaptaki üçüncü Öğeye bakın const.

Sadece bu tavsiyeye uyun

1. Sözcük constyıldız işaretinin solunda görünüyorsa, işaret edilen şey sabittir
2. Sözcük constyıldız işaretinin sağında görünüyorsa, işaretçinin kendisi sabittir
3. Her constiki tarafta görünürse, her ikisi de sabittir

Çok basit ama zor. Biz takas lütfen unutmayın const(herhangi bir veri türü ile eleme int, char,float vb.)

Aşağıdaki örnekleri görelim.

const int *p==> *psalt okunurdur [ psabit bir tamsayının göstergesidir]

int const *p==> *psalt okunurdur [ psabit bir tamsayının göstergesidir]

int *p const==> Yanlış Açıklama. Derleyici bir sözdizimi hatası atar.

int *const p==> psalt okunurdur [ pbir tamsayının sabit göstergesidir]. pBuradaki işaretçi salt okunur olduğundan, bildirim ve tanım aynı yerde olmalıdır.

const int *p const ==> Yanlış Açıklama. Derleyici bir sözdizimi hatası atar.

const int const *p ==> *psalt okunur

const int *const p1 ==> *pve psalt okunurdur [ psabit bir tamsayının sabit bir göstergesidir]. pBuradaki işaretçi salt okunur olduğundan, bildirim ve tanım aynı yerde olmalıdır.

int const *p const ==> Yanlış Açıklama. Derleyici bir sözdizimi hatası atar.

int const int *p ==> Yanlış Açıklama. Derleyici bir sözdizimi hatası atar.

int const const *p ==> *psalt okunur ve eşdeğerdirint const *p

int const *const p ==> *pve psalt okunurdur [ psabit bir tamsayının sabit bir göstergesidir]. pBuradaki işaretçi salt okunur olduğundan, bildirim ve tanım aynı yerde olmalıdır.

C ++ 'da const doğruluğunu çevreleyen başka birçok ince nokta vardır. Burada soru sadece C ile ilgili olduğunu varsayalım, ancak etiket C ++ olduğu için ilgili bazı örnekler vereceğim:

• Genellikle TYPE const &, nesnelerin değiştirilmesini veya kopyalanmasını önleyen dizeler gibi büyük argümanlar iletirsiniz . Misal :

  TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }

  Fakat TYPE & constanlamsızdır çünkü referanslar her zaman sabittir.

• Her zaman sınıfı değiştirmeyen sınıf yöntemlerini etiketlemelisiniz const, aksi takdirde yöntemi bir TYPE const &başvurudan çağıramazsınız . Misal :

  bool TYPE::operator==(const TYPE &rhs) const { ... }

• Hem dönüş değerinin hem de yöntemin sabit olması gereken yaygın durumlar vardır. Misal :

  const TYPE TYPE::operator+(const TYPE &rhs) const { ... }

  Aslında, const yöntemleri dahili sınıf verilerini const-non-const referansı olarak döndürmemelidir.

• Sonuç olarak, const aşırı yüklemesi kullanılarak genellikle hem const hem de const olmayan bir yöntem oluşturulmalıdır. Örneğin, tanımlarsanız T const& operator[] (unsigned i) const;, muhtemelen şu şekilde sabit olmayan sürümü de istersiniz:

  inline T& operator[] (unsigned i) { return const_cast<char&>( static_cast<const TYPE&>(*this)[](i) ); }

Afaik, C'de const işlevi yoktur, üye olmayan işlevlerin kendileri C ++ 'da const olamaz, const yöntemlerinin yan etkileri olabilir ve derleyici yinelenen işlev çağrılarını önlemek için const işlevlerini kullanamaz. Aslında, basit bir int const &referans bile, başka bir yerde değiştirildiği değere tanık olabilir.

C ve C ++ bildirim sözdizimi, orijinal tasarımcılar tarafından tekrar tekrar başarısız bir deneme olarak tanımlanmıştır.

Bunun yerine, “pointer to ” türünü adlandıralımType ; Ben diyeceğim Ptr_:

template< class Type >
using Ptr_ = Type*;

Şimdi Ptr_<char>bir işaretçi char.

Ptr_<const char>bir göstericidir const char.

Ve const Ptr_<const char>bir constişaretçi const char.

Orada.

Benim için, constyani SOL veya SAĞA mı yoksa SOLA ve SAĞA mı göründüğünün konumu *, gerçek anlamı anlamama yardımcı olur.

1. constSOL ile A *arasındaki işaretçi ile gösterilen constnesnenin bir nesne olduğunu belirtir .

2. constİle SAĞ arasındaki A *, işaretçinin bir constişaretçi olduğunu gösterir .

Aşağıdaki tablo Stanford CS106L Standart C ++ Programlama Laboratuvarı Kurs Okuyucudan alınmıştır.

Bu çoğunlukla ikinci satırı ele alır: en iyi uygulamalar, ödevler, fonksiyon parametreleri vb.

Genel Pratik. constYapabileceğiniz her şeyi yapmaya çalışın . Ya da başka bir deyişle, herşeyi constbaşlatabilir ve daha sonra constprogramın çalışmasına izin vermek için gereken minimum s kümesini tam olarak kaldırabilirsiniz . Bu, doğruluk doğruluğuna ulaşmada büyük bir yardımcı olacak ve insanlar değiştirmeleri gerekmeyen şeylere girmeye çalıştıklarında ince hataların ortaya çıkmamasına yardımcı olacaktır.

Veba gibi const_cast <> kullanmaktan kaçının. Bunun için bir veya iki meşru kullanım durumu var, ancak bunlar çok az ve çok uzak. Bir constnesneyi değiştirmeye çalışıyorsanız , onu constilk hızda kimin bildirdiğini bulmak ve ne olması gerektiği konusunda bir fikir birliğine varmak için konuyu onlarla konuşmak için çok daha iyi yapacaksınız .

Bu da çok düzgün bir şekilde ödevlere yol açar. Bir şeye ancak sabit değilse atayabilirsiniz. Sabit bir şeye atamak istiyorsanız, yukarıya bakın. Bildirimlerde int const *foo;ve int * const bar;farklı şeyler olduğunu unutmayın const- buradaki diğer cevaplar bu sorunu takdirle karşıladı, bu yüzden içine girmeyeceğim.

Fonksiyon parametreleri:

Değere göre geçin: ör void func(int param). Arayan sitede şu veya bu şekilde umursamazsınız. Fonksiyonu şöyle bildirmek için kullanım örnekleri olduğu, void func(int const param)ancak arayan üzerinde, sadece fonksiyonun kendisi üzerinde hiçbir etkisi olmayan argümanların çağrı sırasında fonksiyon tarafından değiştirilemeyeceği argümanı yapılabilir .

Referans ile geç: Örneğin void func(int &param), şimdi bir fark yaratıyor. Sadece beyan edildiği gibi funcdeğişmesine izin verilir paramve herhangi bir çağrı sitesi sonuçları ile başa çıkmak için hazır olmalıdır. Beyannamenin değiştirilmesi void func(int const &param)sözleşmeyi değiştirir ve funcşimdi değiştirilemeyen garantiler param, yani neyin geçeceği anlamına gelir. Diğerlerinin de belirttiği gibi, bu, değiştirmek istemediğiniz büyük bir nesneyi ucuza geçirmek için çok yararlıdır. Bir referans iletmek, büyük bir nesneyi değere göre geçirmekten daha ucuzdur.

İşaretçi ile geçin : örneğin void func(int *param)ve void func(int const *param)Bu ikisi, referans sözleşmeleriyle hemen hemen eşanlamlıdır, çağrılan işlevin artık nullptrbaşka bir sözleşme garantisi funcasla içeri girmeyeceğini garanti etmediği sürece kontrol etmesi gereken uyarıyla nullptrbirlikte param.

Bu konudaki fikir parçası. Böyle bir durumda doğruluğu kanıtlamak çok zor, bir hata yapmak çok kolay. Bu yüzden şansınızı denemeyin ve her zaman işaretçi parametrelerini kontrol edin nullptr. Kendinizi acı ve ıstıraptan kurtaracak ve uzun vadede böcek bulmak zor olacaksınız. Ve çek maliyetine gelince, kir ucuzdur ve derleyiciye yerleştirilen statik analizin onu yönetebileceği durumlarda, optimizer yine de onu seçecektir. MSVC için Link Time Code Generation'ı veya GCC için WOPR'yi (sanırım) açın ve program genişliğinde, yani bir kaynak kodu modülü sınırını aşan işlev çağrılarında bile.

Günün sonunda, yukarıdakilerin tümü, her zaman işaretçi referanslarını tercih etmek için çok sağlam bir durum ortaya koyar. Her yönden daha güvenli.

Her iki tarafta int bulunan sabit, sabit int'e işaretçi yapar :

const int *ptr=&i;

veya:

int const *ptr=&i;

constafter int* için sabit bir işaretçi yapacak :

int *const ptr=&i;

Bu durumda, bunların tümü sabit tam sayıya işaretçi olmakla birlikte, bunların hiçbiri sabit işaretçi değildir:

 const int *ptr1=&i, *ptr2=&j;

Bu durumda, hepsi sabit tam sayıya işaretçi ve ptr2 sabit tam sayıya sabit işaretçi olur . Ancak ptr1 sabit bir işaretçi değildir:

int const *ptr1=&i, *const ptr2=&j;

• eğer constbir sola arasında *, bu değeri ifade eder (bu öyle önemli değil ister const intya int const)
• Eğer constbir sağa arasında *, bu işaretçi kendisi belirtmektedir
• ikisi de aynı anda olabilir

Önemli bir nokta: const int *p bahsettiğiniz değerin sabit olduğu anlamına gelmez !! . Bu , işaretçiyi kullanarak değiştiremeyeceğiniz anlamına gelir (yani, $ * p = ... `atayamazsınız). Değerin kendisi başka şekillerde değiştirilebilir. Örneğin

int x = 5;
const int *p = &x;
x = 6; //legal
printf("%d", *p) // prints 6
*p = 7; //error 

Bu, çoğunlukla işlev imzalarında, işlevin iletilen argümanları yanlışlıkla değiştiremeyeceğini garanti etmek için kullanılır.

Sadece diğer açıklamaları takip ederek C için tamlık uğruna, C ++ için emin değilim.

• pp - işaretçi işaretçi
• p - işaretçi
• veri - işaret eden şey, örneklerde x
• kalın - salt okunur değişken

Işaretçi

• p verileri - int *p;
• p verileri -int const *p;
• p verileri -int * const p;
• p verileri -int const * const p;

İşaretçiden işaretçiye

1. pp p verileri - int **pp;
2. pp p verileri -int ** const pp;
3. pp p verileri -int * const *pp;
4. pp p verileri -int const **pp;
5. pp p verileri -int * const * const pp;
6. pp p verileri -int const ** const pp;
7. pp p verileri -int const * const *pp;
8. pp p verileri -int const * const * const pp;

// Example 1
int x;
x = 10;
int *p = NULL;
p = &x;
int **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 2
int x;
x = 10;
int *p = NULL;
p = &x;
int ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 3
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 4
int const x = 10; // Definition must happen during declaration
int const * p = NULL;
p = &x;
int const **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 5
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 6
int const x = 10; // Definition must happen during declaration
int const *p = NULL;
p = &x;
int const ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 7
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 8
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

N Düzensizlik Seviyesi

Sadece devam et, ama insanlık seni aforoz edebilir.

int x = 10;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
int ****pppp = &ppp;

printf("%d \n", ****pppp);

1. const int*- sabit intnesneye işaretçi .

İşaretçinin değerini değiştirebilirsiniz; intnesnenin değerini değiştiremezsiniz , işaretçi işaret eder.

2. const int * const- sabit intnesneye sabit işaretçi .

İşaretçinin değerini veya intişaretçinin işaret ettiği nesnenin değerini değiştiremezsiniz.

3. int const *- sabit intnesneye işaretçi .

Bu ifade 1 ile eşdeğerdir. const int*- İşaretçinin değerini değiştirebilirsiniz, ancak intişaretçinin işaret ettiği nesnenin değerini değiştiremezsiniz .

Aslında, bir 4. seçenek var:

4. int * const- intnesneye sabit işaretçi .

İşaretçinin işaret ettiği nesnenin değerini değiştirebilirsiniz, ancak işaretçinin değerini değiştiremezsiniz. İşaretçi her zaman aynı intnesneyi gösterecektir, ancak bu nesnenin bu değeri intdeğiştirilebilir.

Belirli bir C veya C ++ yapısını belirlemek istiyorsanız, David Anderson tarafından yapılan Clockwise / Spiral Kuralı kullanabilirsiniz ; ama Ross J. Anderson'ın yaptığı oldukça kural olan Anderson'ın Kuralı ile karıştırmamak .