違いは、const char *はconst charへのポインターであるのに対し、char * constはcharへの定数ポインターであるということです。
まず、ポイントされている値は変更できませんが、ポインターは変更できます。 2つ目は、ポイントされている値は変更できますが、ポインターは変更できません（参照と同様）。
もあります
const char * const
これは定数charへの定数ポインターです（したがって、それに関する変更はできません）。
注意：
次の2つの形式は同等です。
const char *
そして
char const *
これの正確な理由はC++標準に記述されていますが、混乱に注意して回避することが重要です。私が好むいくつかのコーディング標準を知っています：
char const
以上
const char
（ポインターの有無にかかわらず）const要素の配置がポインターconstの配置と同じになるようにします。
混乱を避けるために、常にappendはconst修飾子です。
int * mutable_pointer_to_mutable_int;
int const * mutable_pointer_to_constant_int;
int *const constant_pointer_to_mutable_int;
int const *const constant_pointer_to_constant_int;
constは、型宣言の最初のものである場合を除き、その前にあるもの（その左側）を常に変更します。
したがって、これら2つは同じです。
int const *i1;
const int *i2;
const intへのポインターを定義します。 i1とi2が指す場所は変更できますが、それらが指す値は変更できません。
この：
int *const i3 = (int*) 0x12345678;
constポインタを整数に定義し、メモリ位置12345678を指すように初期化します。アドレス12345678のint値を変更できますが、i3が指すアドレスは変更できません。
const * charは無効なCコードであり、無意味です。おそらく、const char *とchar const *の違い、またはおそらくconst char *とchar * constの違いを尋ねるつもりですか？
こちらもご覧ください：
const char*は定数文字へのポインターですchar* constは、文字への定数ポインターです。const char* constは定数文字への定数ポインターです
経験則：定義を右から左に読みます！
const int *foo;
「fooは、変更できないintをポイント（*）（const）」を意味します。
プログラマーにとって、これは「fooが指すもののvalueを変更しない」ことを意味します。
*foo = 123;またはfoo[0] = 123;は無効です。foo = &bar;が許可されています。
int *const foo;
「fooは変更できない（const）で、intを指す（*）」という意味です。
プログラマにとって、これは「fooが参照するメモリアドレスを変更しない」ことを意味します。
*foo = 123;またはfoo[0] = 123;が許可されています。foo = &bar;は無効です。
const int *const foo;
「fooは変更できない（const）であり、変更できないintをポイントする（*）（const）」という意味です。
プログラマーにとって、これは「fooが指すもののvalueを変更せず、addressfooが参照します。
*foo = 123;またはfoo[0] = 123;は無効です。foo = &bar;は無効です。
const char * xここで、Xは基本的に定数値を指す文字ポインターです。
char * const xは定数である文字ポインターを指しますが、それが指している位置は変更できます。
const char * const xは1と2の組み合わせで、定数値を指す定数文字ポインターであることを意味します。
const * char xは、コンパイラエラーを引き起こします。宣言することはできません。
char const * xはポイント1と同じです。
経験則はconstがvar nameである場合、ポインターは一定ですが、ポインティング位置は変更可能です、 elseポインターは一定の場所を指し、ポインターは別の場所を指すことができますが、ポインティング場所の内容は変更できません。
もう1つの経験則は、const isの場所を確認することです。
- *の前 => 値格納される定数
- *の後 => ポインター自体は定数
1つは構文エラーです。たぶんあなたはの違いを意味した
const char * mychar
そして
char * const mychar
その場合、最初のものは変更できないデータへのポインタであり、2番目のものは常に同じアドレスを指すポインタです。
たくさんの答えが、変数宣言のこの特定のインスタンスを理解するための特定のテクニック、経験則などを提供します。ただし、宣言を理解する一般的な手法があります。
時計回り/スパイラルルール
A）
const char *a;
時計回り/スパイラルルールに従って、aは定数の文字へのポインターです。つまり、文字は一定ですが、ポインターは変更できます。つまり、a = "other string";は問題ありませんが、a[2] = 'c';はコンパイルに失敗します
B）
char * const a;
ルールに従って、aは文字へのconstポインターです。つまり、a[2] = 'c';はできますが、a = "other string";はできません
ここにコード付きの詳細な説明があります
/*const char * p;
char * const p;
const char * const p;*/ // these are the three conditions,
// const char *p;const char * const p; pointer value cannot be changed
// char * const p; pointer address cannot be changed
// const char * const p; both cannot be changed.
#include<stdio.h>
/*int main()
{
const char * p; // value cannot be changed
char z;
//*p = 'c'; // this will not work
p = &z;
printf(" %c\n",*p);
return 0;
}*/
/*int main()
{
char * const p; // address cannot be changed
char z;
*p = 'c';
//p = &z; // this will not work
printf(" %c\n",*p);
return 0;
}*/
/*int main()
{
const char * const p; // both address and value cannot be changed
char z;
*p = 'c'; // this will not work
p = &z; // this will not work
printf(" %c\n",*p);
return 0;
}*/
- 定数ポインター：定数ポインターは、プログラム全体を通して、それぞれのデータ型の単一の変数のみを指すことができます。ポインターが指す変数の値を変更できます。初期化は、宣言自体の間に行う必要があります。
構文：
datatype *const var;
char *constはこの場合に該当します。
/*program to illustrate the behaviour of constant pointer */
#include<stdio.h>
int main(){
int a=10;
int *const ptr=&a;
*ptr=100;/* we can change the value of object but we cannot point it to another variable.suppose another variable int b=20; and ptr=&b; gives you error*/
printf("%d",*ptr);
return 0;
}
- const値へのポインター：これでは、ポインターはそれぞれの型の変数をいくつでも指すことができますが、その特定の時点でポインターが指すオブジェクトの値を変更することはできません。
構文：
const datatype *varor datatype const *var
const char*はこの場合に該当します。
/* program to illustrate the behavior of pointer to a constant*/
#include<stdio.h>
int main(){
int a=10,b=20;
int const *ptr=&a;
printf("%d\n",*ptr);
/* *ptr=100 is not possible i.e we cannot change the value of the object pointed by the pointer*/
ptr=&b;
printf("%d",*ptr);
/*we can point it to another object*/
return 0;
}
int const *（またはconst int *）を使用することはconst int変数を指すポインターに関するものではなく、この変数はこの特定のポインターに対してconstであることを指摘したいと思います。
例えば：
int var = 10;
int const * _p = &var;
上記のコードは問題なくコンパイルできます。 _pはconst変数を指しますが、var自体は定数ではありません。
char * constおよびconst char *？
- 定数値を指す
const char * p; //値は変更できません
- 値への定数ポインター
char * const p; //アドレスは変更できません
- 定数値への定数ポインター
const char * const p; //両方を変更することはできません。
const修飾子は、そのすぐ左の用語に適用されます。これの唯一の例外は、その左側に何もない場合で、そのすぐ右側に適用されます。
これらはすべて、「定数charへの定数ポインター」と同等の言い方です。
const char * constconst char const *char const * constchar const const *
Const char *とchar * constを意味すると思います。
最初のconst char *は、定数文字へのポインターです。ポインター自体は変更可能です。
2番目のchar * constは、文字への定数ポインターです。ポインターは変更できず、ポインターが指す文字は変更できます。
そして、ポインタと文字を変更できないconst char * constがあります。
2つのルール
If const is between char and *, it will affect the left one.If const is not between char and *, it will affect the nearest one.
例えば.
char const *. This is a pointer points to a constant char.char * const. This is a constant pointer points to a char.
// Some more complex constant variable/pointer declaration.
// Observing cases when we get error and warning would help
// understanding it better.
int main(void)
{
char ca1[10]= "aaaa"; // char array 1
char ca2[10]= "bbbb"; // char array 2
char *pca1= ca1;
char *pca2= ca2;
char const *ccs= pca1;
char * const csc= pca2;
ccs[1]='m'; // Bad - error: assignment of read-only location ‘*(ccs + 1u)’
ccs= csc; // Good
csc[1]='n'; // Good
csc= ccs; // Bad - error: assignment of read-only variable ‘csc’
char const **ccss= &ccs; // Good
char const **ccss1= &csc; // Bad - warning: initialization from incompatible pointer type
char * const *cscs= &csc; // Good
char * const *cscs1= &ccs; // Bad - warning: initialization from incompatible pointer type
char ** const cssc= &pca1; // Good
char ** const cssc1= &ccs; // Bad - warning: initialization from incompatible pointer type
char ** const cssc2= &csc; // Bad - warning: initialization discards ‘const’
// qualifier from pointer target type
*ccss[1]= 'x'; // Bad - error: assignment of read-only location ‘**(ccss + 8u)’
*ccss= ccs; // Good
*ccss= csc; // Good
ccss= ccss1; // Good
ccss= cscs; // Bad - warning: assignment from incompatible pointer type
*cscs[1]= 'y'; // Good
*cscs= ccs; // Bad - error: assignment of read-only location ‘*cscs’
*cscs= csc; // Bad - error: assignment of read-only location ‘*cscs’
cscs= cscs1; // Good
cscs= cssc; // Good
*cssc[1]= 'z'; // Good
*cssc= ccs; // Bad - warning: assignment discards ‘const’
// qualifier from pointer target type
*cssc= csc; // Good
*cssc= pca2; // Good
cssc= ccss; // Bad - error: assignment of read-only variable ‘cssc’
cssc= cscs; // Bad - error: assignment of read-only variable ‘cssc’
cssc= cssc1; // Bad - error: assignment of read-only variable ‘cssc’
}