차이점은 무엇입니까?

char * const 

과

const char *

차이점은에 const char *대한 포인터 const char이고, char * const에 대한 상수 포인터 char입니다.

첫 번째로 가리키는 값은 변경할 수 없지만 포인터는 변경할 수 있습니다. 두 번째, 가리키는 값은 변경 될 수 있지만 포인터는 참조와 유사하지 않습니다.

또 한있다

const char * const

상수 char에 대한 상수 포인터입니다 (따라서 변경할 수는 없습니다).

노트 :

다음 두 가지 형태가 동일합니다.

const char *

과

char const *

정확한 이유는 C ++ 표준에 설명되어 있지만 혼동을 피하고 피하는 것이 중요합니다. 선호하는 몇 가지 코딩 표준을 알고 있습니다.

char const

위에

const char

(포인터가 있거나없는) const요소 의 배치 는 pointer와 동일 const합니다.

혼동을 피하려면 항상 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 형식 선언에서 첫 번째 일 때를 제외하고 그 앞 (왼쪽)에 오는 것을 항상 수정하고, 그 뒤에 오는 것을 수정합니다 (오른쪽에).

따라서이 두 가지는 동일합니다.

int const *i1;
const int *i2;

그들은에 대한 포인터를 정의합니다 const int. 위치 i1와 i2지점을 변경할 수 있지만 해당 지점의 값을 변경할 수는 없습니다.

이:

int *const i3 = (int*) 0x12345678;

const정수에 대한 포인터를 정의하고 메모리 위치 12345678을 가리 키도록 초기화합니다 int. 주소 12345678 의 값을 변경할 수 있지만 i3가리키는 주소는 변경할 수 없습니다 .

const * char유효하지 않은 C 코드이며 의미가 없습니다. 아마도 당신은 a const char *와 a char const *의 차이 또는 a 와 a 의 차이를 물어 보려고했습니다 const char *.char * const ?

또한보십시오:

• const 포인터는 무엇입니까 (const 객체에 대한 포인터와 반대)?
• C의 Const
• C ++에서 const 선언의 차이점
• C ++ const 질문
• const char * 변수의 값을 변경할 수있는 이유는 무엇입니까?

const char*상수 문자
char* const에 대한 포인터입니다. 문자
const char* const에 대한 상수 포인터입니다. 상수 문자 에 대한 상수 포인터입니다.

경험 법칙 : 정의를 오른쪽에서 왼쪽으로 읽으십시오!

const int *foo;

" foo포인트 ( *)는 int변경할 수없는 ( const)"을 의미합니다.
프로그래머에게 이것은 " 이것이 가리키는 것의 가치 를 바꾸지 않을 것"을 의미 foo합니다.

• *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변경하지 않으며 참조 하는 주소 를 변경하지 않을 것 foo" 을 의미합니다.

• *foo = 123;또는 foo[0] = 123;유효하지 않습니다.
• foo = &bar; 유효하지 않습니다.

1. const char * x 여기서 X는 기본적으로 상수 값을 가리키는 문자 포인터입니다.

2. char * const x 는 상수 인 문자 포인터를 나타내지 만, 가리키는 위치는 변경 될 수 있습니다.

3. const char * const x 는 1과 2의 조합으로 상수 값을 가리키는 상수 문자 포인터임을 의미합니다.

4. const * char x 는 컴파일러 오류를 일으 킵니다. 선언 할 수 없습니다.

5. char const * x 는 포인트 1과 같습니다.

일반적으로 const 가 var name 인 경우 포인터는 일정하지만 포인팅 위치는 변경할 수 있습니다 . 그렇지 않으면 포인터는 일정한 위치를 가리키고 포인터는 다른 위치를 가리킬 수 있지만 포인팅 위치 내용은 변경할 수 없습니다 .

첫 번째는 구문 오류입니다. 아마 당신은 차이를 의미

const char * mychar

과

char * const mychar

이 경우 첫 번째는 변경할 수없는 데이터에 대한 포인터이고 두 번째는 항상 동일한 주소를 가리키는 포인터입니다.

또 다른 규칙은 const가 어디에 있는지 확인하는 것 입니다 .

1. * => 저장된 값 이 일정 하기 전에
2. * => 포인터 자체가 일정 한 후

많은 답변은 특정 변수 선언의 특정 인스턴스를 이해하기 위해 특정 기술, 경험 규칙 등을 제공합니다. 그러나 선언을 이해하는 일반적인 기술이 있습니다.

시계 방향 / 나선 규칙

ㅏ)

const char *a;

시계 방향 / 나선형 규칙에 따라 a일정한 문자를 가리키는 포인터입니다. 이것은 문자가 일정하지만 포인터가 변경 될 수 있음을 의미합니다. 즉 a = "other string";괜찮지 만a[2] = 'c'; 컴파일에 실패합니다

비)

char * const a;

규칙 a에 따라 문자에 대한 const 포인터입니다. 즉 할 수는 a[2] = 'c';있지만 할 수는 없습니다a = "other string";

나는 당신이 const char * 및 char * const을 의미한다고 가정합니다.

첫 번째 인 const char *는 상수 문자에 대한 포인터입니다. 포인터 자체는 변경 가능합니다.

두 번째 char * const는 문자에 대한 상수 포인터입니다. 포인터는 변경할 수없는 문자를 변경할 수 없습니다.

그리고 포인터와 문자를 변경할 수없는 const char * const가 있습니다.

다음은 코드에 대한 자세한 설명입니다

/*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;
}*/

// 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’
}

1. 상수 포인터 : 상수 포인터는 전체 프로그램 동안 각 데이터 유형의 단일 변수만을 가리킬 수 있으며 포인터가 가리키는 변수의 값을 변경할 수 있습니다. 선언 자체는 선언하는 동안 초기화해야합니다.

통사론:

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;
}

2. const 값에 대한 포인터 : 여기서 포인터는 각 유형의 여러 변수를 가리킬 수 있지만 특정 시간에 포인터가 가리키는 객체의 값을 변경할 수 없습니다.

통사론:

const datatype *var또는 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;
    }

char * const와 const char *?

1. 상수 값을 가리키는

const char * p; // 값을 변경할 수 없습니다

2. 값에 대한 상수 포인터

char * const p; // 주소를 변경할 수 없습니다

3. 상수 값에 대한 상수 포인터

const char * const p; // 둘 다 변경할 수 없습니다.

그만큼 const개질제는 바로 왼쪽 용어에 적용된다. 이것에 대한 유일한 예외는 왼쪽에 아무것도 없을 때 오른쪽에있는 것에 적용됩니다.

다음은 "상수에 대한 상수 포인터"라고 말하는 것과 동등한 방법입니다 char.

• const char * const
• const char const *
• char const * const
• char const const *

두 가지 규칙

1. If const is between char and *, it will affect the left one.
2. If const is not between char and *, it will affect the nearest one.

예 :

1. char const *. This is a pointer points to a constant char.
2. char * const. This is a constant pointer points to a char.

int const *(또는 const int *) 사용은 const int변수를 가리키는 포인터에 관한 것이 아니라이 변수 라는 것을 지적하고 싶습니다.const 가이 특정 포인터를위한 .

예를 들면 다음과 같습니다.

int var = 10;
int const * _p = &var;

위의 코드는 완벽하게 컴파일됩니다. 상수는 아니지만 변수를 _p가리 킵니다 .constvar

나는 체코 책에서 C에 대해 기억합니다. 변수로 시작하고 왼쪽으로 가라는 선언을 읽으십시오. 그래서

char * const a;

다음과 같이 읽을 수 있습니다 : " a는 " 에 대한 상수 포인터 유형의 변수입니다 char.

char const * a;

" a는 char 유형의 상수 변수에 대한 포인터입니다. 이것이 도움이되기를 바랍니다.

보너스:

const char * const a;

achar 유형의 상수 변수에 대한 상수 포인터를 읽습니다 .