使用方法まで私はいつも混乱const int*、const int * constとint const *正しく。できることとできないことを定義する一連のルールはありますか？

割り当て、関数への受け渡しなど、すべてのすべきこととすべきでないことを知りたい

（時計回り/スパイラルルールによって駆動されるように）逆に読みます：

• int* -intへのポインタ
• int const * -const intへのポインタ
• int * const -intへのconstポインター
• int const * const -const intへのconstポインタ

これで、最初constのものは型のどちら側にも置くことができます。

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

あなたが本当に夢中になりたいなら、あなたはこのようなことをすることができます：

• int ** -intへのポインターへのポインター
• int ** const -intへのポインタへのconstポインタ
• int * const * -intへのconstポインタへのポインタ
• int const ** -const intへのポインタへのポインタ
• int * const * const -intへのconstポインタへのconstポインタ
• ...

そして、私たちが以下の意味を明確にするために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.           

foo定数整数への変数ポインターです。これにより、ポイントする値を変更できますが、ポイントする値は変更できません。ほとんどの場合、これはCスタイルの文字列で見られ、へのポインタがありconst charます。指し示す文字列は変更できますが、これらの文字列の内容を変更することはできません。これは、文字列自体がプログラムのデータセグメント内にあり、変更してはならない場合に重要です。

bar変更可能な値への定数または固定ポインターです。これは、余分な構文糖がない参照のようなものです。このため、T* constポインタを許可する必要がない限り、通常はポインタを使用する参照を使用しNULLます。

時計回り/スパイラルルールについて知らない場合：変数の名前から始めて、時計回りに（この場合は後方に）移動し、次のポインターに移動するか、を入力します。式が終了するまで繰り返します。

ここにデモがあります：

私はすべてここですでに回答されていると思いますが、あなたがtypedefsに注意する必要があることを付け加えておきます！それらは単なるテキスト置換ではありません。

例えば：

typedef char *ASTRING;
const ASTRING astring;

のタイプはでastringはchar * constなくconst char *です。これは、私が常にconst型の右側に置く傾向がある1つの理由であり、最初は決してしません。

ほとんどの人が指摘したように：

何の違いだconst X* p、X* const pとconst X* const p？

ポインタ宣言は右から左に読む必要があります。

• const X* p 「pはconstであるXを指す」を意味します。Xオブジェクトはpを介して変更できません。

• X* const p 「pは非constであるXへのconstポインターです」：ポインターp自体を変更することはできませんが、pを介してXオブジェクトを変更できます。

• const X* const p 「pはconstであるXへのconstポインターです」：ポインターp自体を変更することも、pを介してXオブジェクトを変更することもできません。

1. 定数参照：

   定数である変数（ここではint）への参照。参照は実際の値よりもサイズが小さいため、主に変数を参照として渡しますが、副作用があり、それは実際の変数のエイリアスのようなものであるためです。エイリアスへのフルアクセスを通じて誤ってメイン変数を変更する可能性があるため、この副作用を防ぐために定数を一定にします。

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

2. 定数ポインター

   定数ポインタが変数を指すと、他の変数を指すことはできません。

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

3. 定数へのポインタ

   それが指す変数の値を変更できないポインターは、定数へのポインターと呼ばれます。

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

4. 定数への定数ポインター

   定数への定数ポインターは、それが指しているアドレスを変更できず、そのアドレスに保持されている値も変更できないポインターです。

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

一般的なルールは、constキーワードはその直前にあるものに適用されるということです。例外として、開始constは次のものに適用されます。

• const int*はと同じでint const*、「定数intへのポインタ」を意味します。
• const int* constと同じでint const* const、「定数intへの定数ポインタ」を意味します。

編集： すべきこととすべきでないことについて、この答えが十分でない場合は、あなたが望むものについてより正確にすることができますか？

この質問は、質問で述べたように、タイプIDが受け入れられた後のconstを行うのが好きな理由を正確に示しています。

要するに、ルールを覚える最も簡単な方法は、「c​​onst」が適用されるものの後に来るということです。したがって、あなたの質問では、「int const *」はintが定数であることを意味し、「int * const」はポインタが定数であることを意味します。

誰かが最前線に置くことを決定した場合（例： "const int *"）、その場合の特別な例外として、それはその後のものに適用されます。

多くの人々は、この特別な例外をより見栄えが良いと思うので、使用したいと考えています。例外なので混乱するので嫌いです。

の簡単な使用const。

最も簡単な使い方は、名前付き定数を宣言することです。これを行うには、定数を変数のように宣言しますが、そのconst前に追加します。もちろん、値を変更するため、後で値を設定することはできないため、コンストラクタですぐに初期化する必要があります。例えば：

const int Constant1=96; 

想像を絶すると呼ばれるConstant1、値96の整数定数を作成します。

このような定数は、プログラムで使用されるパラメーターに役立ちますが、プログラムのコンパイル後に変更する必要はありません。#defineメインコンパイラに到達する前にプリプロセッサによってプログラムテキストに代入されるだけでなく、コンパイラ自体によって理解および使用されるという点で、Cプリプロセッサコマンドよりもプログラマにとって利点があります。そのため、エラーメッセージははるかに役立ちます。

ポインターでも機能しますがconst、ポインターまたはポインターが指すものが定数であるか、またはその両方であるかを判断する場所に注意する必要があります。例えば：

const int * Constant2 

それConstant2が定数整数への可変ポインタであることを宣言し、そして：

int const * Constant2

同じことをする代替構文ですが、

int * const Constant3

それConstant3が可変整数への定数ポインタであることを宣言し、

int const * const Constant4

Constant4定数整数への定数ポインタであることを宣言します。基本的に 'const'はそのすぐ左にあるものすべてに適用されます（そこに何もない場合を除いて、そのすぐ右にあるものに適用されます）。

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

C ++の教祖スコットマイヤーズによってこの本に出会うまで、私はあなたと同じ疑問を抱きました。この本の3番目の項目を参照してください。彼はの使用について詳しく説明していconstます。

このアドバイスに従ってください

1. 単語constがアスタリスクの左側にある場合、指し示されているのは定数です
2. 単語constがアスタリスクの右側にある場合、ポインタ自体は定数です
3. const両側に現れる場合、両方が一定です

シンプルですがトリッキーです。我々は入れ替えることができますのでご注意くださいconst任意のデータ型（と修飾子をint、char、float、など）。

以下の例を見てみましょう。

const int *p==> *pは読み取り専用です[ pは定数整数へのポインタです]

int const *p==> *pは読み取り専用です[ pは定数整数へのポインタです]

int *p const==> 誤った声明。コンパイラーは構文エラーをスローします。

int *const p==> pは読み取り専用です[ pは整数への定数ポインタです]。ここでのポインターpは読み取り専用であるため、宣言と定義は同じ場所になければなりません。

const int *p const ==> 誤った声明。コンパイラーは構文エラーをスローします。

const int const *p ==> *pは読み取り専用です

const int *const p1 ==> *pおよびp読み取り専用です[ pは定数整数への定数ポインター]。ここでのポインターpは読み取り専用であるため、宣言と定義は同じ場所になければなりません。

int const *p const ==> 誤った声明。コンパイラーは構文エラーをスローします。

int const int *p ==> 誤った声明。コンパイラーは構文エラーをスローします。

int const const *p ==> *pは読み取り専用で、以下と同等ですint const *p

int const *const p ==> *pおよびp読み取り専用です[ pは定数整数への定数ポインター]。ここでのポインターpは読み取り専用であるため、宣言と定義は同じ場所になければなりません。

C ++のconstの正確性には、他にも多くの微妙な点があります。ここでの質問は単にCに関するものだと思いますが、タグがC ++であるため、関連する例をいくつか示します。

• 文字列などの大きな引数を渡すとTYPE const &、オブジェクトが変更またはコピーされるのを防ぐことができます。例：

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

  ただしTYPE & const、参照は常にconstであるため、意味がありません。

• クラスを変更しないクラスメソッドには常にラベルを付けるconst必要があります。そうしないと、TYPE const &参照からメソッドを呼び出すことができません。例：

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

• 戻り値とメソッドの両方がconstでなければならない一般的な状況があります。例：

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

  実際、constメソッドは、constへの参照として内部クラスデータを返してはなりません。

• その結果、constオーバーロードを使用して、constメソッドとnon-constメソッドの両方を作成する必要があることがよくあります。たとえば、を定義するT const& operator[] (unsigned i) const;場合は、おそらく次のようにして、非constバージョンも必要になります。

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

Afaik、Cにはconst関数がないため、非メンバー関数自体をC ++でconstにすることはできません。constメソッドには副作用があり、コンパイラーはconst関数を使用して関数呼び出しの重複を回避できません。実際、単純なint const &参照でさえ、それが参照する値が他の場所で変更されるのを目撃するかもしれません。

CおよびC ++宣言構文は、元の設計者によって、失敗した実験として繰り返し説明されてきました。

代わりに、タイプに「ポインタ」という名前を付けましょうType。私はそれを呼びますPtr_：

template< class Type >
using Ptr_ = Type*;

今Ptr_<char>はへのポインタcharです。

Ptr_<const char>へのポインタconst charです。

そしてへconst Ptr_<const char>のconstポインタconst charです。

そこ。

私にとっては、のconst相対的な位置、つまり、左または右に表示されるか、左と右の両方に表示されるか*は、実際の意味を理解するのに役立ちます。

1. A constの左側には、*ポインタが指すオブジェクトであることを示すconstオブジェクト。

2. const右側には、*ポインタがあることを示すconstポインタ。

次の表は、スタンフォードCS106L標準C ++プログラミングラボコースリーダーからの抜粋です。

これは主に2行目を扱います：ベストプラクティス、割り当て、関数パラメーターなど。

一般的な練習。constできることはすべて作るようにしてください。または別の言い方をすれば、すべてconstを最初から作成し、constプログラムが機能するために必要な最小限ののセットを正確に削除します。これは、const-correctnessを達成する上で大きな助けとなり、変更してはならないものに人々が割り当てようとしたときに、微妙なバグが導入されないようにするのに役立ちます。

ペストのようなconst_cast <>は避けてください。これには1つまたは2つの正当な使用例がありますが、その数は非常に少なく、はるかに異なります。constオブジェクトを変更しようとしている場合constは、最初のペースでオブジェクトを宣言した人を見つけ、何が起こるかについてコンセンサスを得るために彼らと話し合って問題を解決する方がはるかに効果的です。

これは非常にきちんと割り当てにつながります。constでない場合にのみ、何かに代入できます。constであるものに割り当てたい場合は、上記を参照してください。宣言int const *foo;とint * const bar;さまざまなことで覚えておいてくださいconst-ここでの他の回答はその問題を立派にカバーしているので、ここでは触れません。

関数パラメーター：

値渡し：たとえばvoid func(int param)、呼び出し元サイトでは、どちらかを気にしません。引数は、関数を宣言するためのユースケースvoid func(int const param)があるが、渡された値は呼び出し中に関数によって変更できないという点で、関数自体にのみ影響し、呼び出し元には影響を与えないようにすることができます。

参照渡し：たとえば、void func(int &param)今では違いが出ます。宣言されたとおりfunc、変更が許可されてparamおり、呼び出し元のサイトは結果に対処する準備ができている必要があります。宣言をvoid func(int const &param)変更して契約を変更し、func変更できないことを保証しますparam。つまり、渡されたものが戻ってきます。他の人が指摘したように、これは、変更したくない大きなオブジェクトを安く渡すために非常に便利です。参照を渡す方が、値の大きいオブジェクトを渡すよりもはるかに安価です。

ポインタによる受け渡し：たとえばvoid func(int *param)およびvoid func(int const *param)これら2つは参照の対応物とほとんど同義です。nullptrただし、他の契約上の保証によってinをfunc受信しないことが保証されていない限り、呼び出された関数はチェックする必要があるという警告があります。nullptrparam

そのトピックに関する意見の一部。このようなケースで正しさを証明することは地獄のように難しいです。間違いを犯すのはあまりにも簡単です。ですから、チャンスをとらないでくださいnullptr。常にのポインタパラメータを確認してください。あなたはあなた自身の痛みと苦しみを救い、長期的にバグを見つけるのを難しくします。そして、チェックのコストに関しては、それは非常に安価であり、コンパイラに組み込まれた静的分析がそれを管理できる場合、オプティマイザはとにかくそれを排除します。MSVCのリンクタイムコード生成、またはGCCのWOPR（私は思う）をオンにすると、プログラム全体、つまり、ソースコードモジュールの境界を越える関数呼び出しでも、プログラム全体が得られます。

結局のところ、上記のすべてが常にポインタへの参照を好む非常に堅実なケースを作ります。彼らはただずっと安全です。

どちらかの側にintを持つconstは、定数intへのポインターを作成します。

const int *ptr=&i;

または：

int const *ptr=&i;

constafter *はintへの定数ポインタを作成します：

int *const ptr=&i;

この場合、これらはすべて定数integerへのポインターですが、これらはどれも定数ポインターではありません。

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

この場合、すべてが定数整数へのポインターであり、ptr2は定数整数への定数ポインターです。しかし、ptr1は定数ポインタではありません。

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

• 場合constで左への*、それは値を参照（だかどうかは関係ありませんconst intかint const）
• の右側にある場合constは、ポインタ自体を参照します*
• それは同時に両方にすることができます

重要なポイント：const int *p 参照している値が一定であるという意味ではありません!! 。これは、そのポインターを通じて変更できないことを意味します（つまり、$ * p = ... `を割り当てることはできません）。値自体は他の方法で変更される場合があります。例えば

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

これは、関数が誤って渡された引数を変更できないことを保証するために、主に関数シグネチャで使用されることを意図しています。

他の説明に続くCの完全性のために、C ++についてはわかりません。

• pp-ポインターへのポインター
• p-ポインター
• データ-指摘されていること、例 x
• 太字 -読み取り専用変数

ポインタ

• pデータ- int *p;
• p データ -int const *p;
• pデータ-int * const p;
• p データ -int const * const p;

ポインターへのポインター

1. pp pデータ- int **pp;
2. pp pデータ-int ** const pp;
3. pp pデータ-int * const *pp;
4. pp p データ -int const **pp;
5. pp pデータ-int * const * const pp;
6. pp p データ -int const ** const pp;
7. pp p データ -int const * const *pp;
8. pp p データ -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レベル

続けるだけですが、人類があなたを破門することがあります。

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

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

1. const int*-定数intオブジェクトへのポインタ。

ポインタの値を変更できます。intポインタが指すオブジェクトの値を変更することはできません。

2. const int * const-定数intオブジェクトへの定数ポインタ。

ポインターの値や、ポインターが指すintオブジェクトの値を変更することはできません。

3. int const *-定数intオブジェクトへのポインタ。

このステートメントは1と同等const int*です。-ポインターの値は変更できますが、ポインターが指すintオブジェクトの値は変更できません。

実際には、4番目のオプションがあります。

4. int * const- intオブジェクトへの定数ポインタ。

ポインタが指すオブジェクトの値は変更できますが、ポインタ自体の値は変更できません。ポインターは常に同じintオブジェクトを指しますが、このintオブジェクトのこの値は変更できます。

特定のタイプのCまたはC ++構成を判別したい場合は、David Andersonによって作成された時計回り/らせん規則を使用できます。ただし、Ross J. Andersonが作成したAndersonの規則と混同しないようにしてください。