etc./StackOverFlow

const int*, const int * const 및 int const *의 차이점은 무엇입니까?

청렴결백한 만능 재주꾼 2022. 2. 8. 08:37
반응형

질문자 :ultraman


const int* , const int * const 및 int const * 올바르게 사용하는 방법을 엉망으로 만듭니다. 할 수 있는 것과 할 수 없는 것을 정의하는 일련의 규칙이 있습니까?

할당, 함수 전달 등과 관련하여 해야 할 일과 하지 말아야 할 일을 모두 알고 싶습니다.



시계 방향/나선형 규칙에 따라 거꾸로 읽으십시오.

  • int* - int*
  • int const * - const에 대한 포인터 int
  • int * const - int에 대한 const 포인터
  • int const * const - const에 대한 const 포인터 int

이제 첫 번째 const 는 다음과 같이 유형의 양쪽에 있을 수 있습니다.

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

정말 미치고 싶다면 다음과 같이 할 수 있습니다.

  • int ** 포인터에 대한 포인터
  • int ** const - int에 대한 포인터에 대한 const 포인터
  • int * const * - const에 대한 포인터 int에 대한 포인터
  • int const ** - const에 대한 포인터에 대한 포인터 int
  • int * const * const - const에 대한 const 포인터 int에 대한 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 는 상수 정수에 대한 변수 포인터입니다. 이렇게 하면 가리키는 값을 변경할 수 있지만 가리키는 값은 변경할 수 없습니다. const char 대한 포인터가 있는 C 스타일 문자열에서 볼 수 있습니다. 가리키는 문자열을 변경할 수 있지만 이러한 문자열의 내용은 변경할 수 없습니다. 이것은 문자열 자체가 프로그램의 데이터 세그먼트에 있고 변경되어서는 안 되는 경우에 중요합니다.

bar 는 변경할 수 있는 값에 대한 상수 또는 고정 포인터입니다. 이것은 추가 구문 설탕이 없는 참조와 같습니다. 이 사실 때문에 일반적으로 NULL 포인터를 허용해야 하는 경우가 아니면 T* const


Matt Price

시계 방향 / 나선형 규칙에 대해 모르는 사람들을 위해 시작 변수의 이름에서, 시계 방향으로 이동 다음 포인터 나 유형 (이 경우, 뒤로 이동). 표현식이 끝날 때까지 반복합니다.

데모는 다음과 같습니다.

int에 대한 포인터

int const에 대한 const 포인터

int const에 대한 포인터

const int에 대한 포인터

int에 대한 const 포인터


Shijing Lv

나는 모든 것이 이미 여기에 답이 있다고 생각하지만 typedef 주의해야 한다고 덧붙이고 싶습니다! 그것들은 단순한 텍스트 교체가 아닙니다.

예를 들어:

 typedef char *ASTRING; const ASTRING astring;

astring 의 유형은 const char * 아니라 char * const 입니다. const 를 유형의 오른쪽에 두는 경향이 있는 한 가지 이유이며 시작 부분에는 절대 넣지 않습니다.


Kaz Dragon

거의 모든 사람들이 지적한 것처럼:

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 개체를 변경할 수도 없습니다.


luke

  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

Behrooz Tabesh

일반적인 규칙은 const 키워드가 바로 앞에 오는 것에 적용된다는 것입니다. 예외, 시작 const 는 다음에 적용됩니다.

  • const int* 는 int const* 와 동일하며 "상수 int에 대한 포인터"를 의미합니다.
  • const int* const 는 int const* const 와 동일하며 "상수 int에 대한 상수 포인터"를 의미합니다.

편집: Dos와 Don'ts의 경우 이 답변 이 충분하지 않은 경우 원하는 것에 대해 더 정확할 수 있습니까?


AProgrammer

이 질문은 내가 내 질문에 언급한 방식 이 const 후에 유형 ID가 허용되는 방식을 선호하는 이유를 정확하게 보여줍니다.

요컨대 규칙을 기억하는 가장 쉬운 방법은 "const"가 적용되는 항목 뒤에 오는 것입니다. 따라서 귀하의 질문에서 "int const *"는 int가 일정함을 의미하고 "int * const"는 포인터가 일정함을 의미합니다.

누군가가 그것을 맨 앞에 놓기로 결정했다면(예: "const int *"), 그 경우의 특별한 예외로서 뒤에 오는 것에 적용됩니다.

많은 사람들은 이 특별한 예외가 더 보기 좋게 보이기 때문에 이 예외를 사용하고 싶어합니다. 나는 예외이기 때문에 그것을 싫어하고, 따라서 사물을 혼란스럽게 합니다.


T.E.D.

const 간단한 사용.

가장 간단한 사용법은 명명된 상수를 선언하는 것입니다. 이렇게 하려면 변수인 것처럼 상수를 선언하지만 그 const 를 추가합니다. 생성자에서 즉시 초기화해야 합니다. 물론 나중에 값을 변경하면 값을 설정할 수 없기 때문입니다. 예를 들어:

 const int Constant1=96;

정수 상수를 생성합니다. 상상할 수 없을 정도로 값이 96인 Constant1

이러한 상수는 프로그램에서 사용되지만 프로그램이 컴파일된 후에 변경할 필요가 없는 매개변수에 유용합니다. #define 명령에 비해 프로그래머에게 이점이 있습니다. 주 컴파일러에 도달하기 전에 전처리기에 의해 프로그램 텍스트로 대체될 뿐만 아니라 컴파일러 자체에서 이해하고 사용하므로 오류 메시지가 훨씬 더 유용합니다.

포인터와도 작동하지만 포인터 또는 포인터가 가리키는 대상이 상수인지 또는 둘 다인지를 결정하기 위해 const 예를 들어:

 const int * Constant2

Constant2 가 상수 정수에 대한 변수 포인터임을 선언하고 다음을 수행합니다.

 int const * Constant2

동일한 작업을 수행하는 대체 구문이지만

 int * const Constant3

Constant3 이 변수 정수에 대한 상수 포인터임을 선언하고

 int const * const Constant4

Constant4 가 상수 정수에 대한 상수 포인터임을 선언합니다. 기본적으로 'const'는 바로 왼쪽에 있는 모든 항목에 적용됩니다(아무 것도 없는 경우 제외하고 바로 오른쪽에 있는 항목에 적용됨).

참조: http://duramecho.com/ComputerInformation/WhyHowCppConst.html


ufukgun

C++ 전문가 Scott Meyers가 쓴 이 책을 접하기 전까지 나는 당신과 같은 의심을 품고 있었습니다. const 사용에 대해 자세히 설명하는 이 책의 세 번째 항목을 참조하십시오.

이 조언을 따르십시오

  1. const 라는 단어가 별표 왼쪽에 나타나면 가리키는 것은 상수입니다.
  2. 단어 const 가 별표 오른쪽에 나타나면 포인터 자체가 상수입니다.
  3. const 가 양쪽에 나타나면 둘 다 상수입니다.

rgk

간단하지만 까다롭습니다. 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 는 읽기 전용이므로 선언과 정의가 같은 위치에 있어야 합니다.


Abhijit Sahu

나를 위해,의 위치 const 는 왼쪽 또는 오른쪽 또는 왼쪽과 오른쪽 기준으로 모두 표시할지 여부 즉, * 나를 실제 의미를 파악하는 데 도움이됩니다.

  1. const 의 왼쪽에 * 포인터가 가리키는 객체가 있음을 나타냅니다 const 객체입니다.

  2. const 의 오른쪽에있는 * 포인터가 있음을 나타냅니다 const 포인터.

다음 표는 Stanford CS106L Standard C++ Programming Laboratory Course Reader에서 가져온 것입니다.

여기에 이미지 설명 입력


sri

C++의 const 정확성을 둘러싼 다른 많은 미묘한 점이 있습니다. 여기의 질문은 단순히 C에 관한 것이지만 태그가 C++이므로 몇 가지 관련 예제를 제공하겠습니다.

  • 객체가 수정되거나 복사되는 것을 방지하는 TYPE const & 로 문자열과 같은 큰 인수를 전달하는 경우가 많습니다. 예시 :

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

    그러나 참조가 항상 const이기 때문에 TYPE & const

  • 클래스를 수정하지 않는 클래스 메서드에는 항상 const TYPE const & 참조에서 메서드를 호출할 수 없습니다. 예시 :

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

  • 반환 값과 메서드가 모두 const여야 하는 일반적인 상황이 있습니다. 예시 :

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

    사실, const 메서드는 내부 클래스 데이터를 const가 아닌 것에 대한 참조로 반환해서는 안 됩니다.

  • 결과적으로 const 오버로딩을 사용하여 const 및 비 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 & reference도 참조하는 값이 다른 곳에서 변경되는 것을 목격할 수 있습니다.


Jeff Burdges

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 .

거기.

여기에 이미지 설명 입력


Cheers and hth. - Alf

양쪽에 int가 있는 const는 상수 int에 대한 포인터를 만듭니다.

 const int *ptr=&i;

또는:

 int const *ptr=&i;

* 뒤의 const 는 int에 대한 상수 포인터를 만듭니다.

 int *const ptr=&i;

이 경우 이들 모두는 정수 정수에 대한 포인터이지만 이들 중 어느 것도 상수 포인터가 아닙니다.

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

이 경우 모두는 상수 정수에 대한 포인터이고 ptr2는 상수 정수에 대한 상수 포인터 입니다. 그러나 ptr1은 상수 포인터가 아닙니다.

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

Muhammad Inshaal Muddassir

이것은 대부분 두 번째 줄인 모범 사례, 할당, 함수 매개변수 등을 다룹니다.

일반 관행. 가능한 모든 것을 const 로 만드십시오. 다른 식으로 말하면 const 부터 모든 것을 const로 만든 다음 프로그램이 작동하는 데 필요한 const 집합을 정확히 제거합니다. 이것은 const-correctness를 얻는 데 큰 도움이 될 것이며 사람들이 수정해서는 안 되는 것에 할당하려고 할 때 미묘한 버그가 도입되지 않도록 하는 데 도움이 될 것입니다.

전염병처럼 const_cast<>를 피하세요. 하나 또는 두 개의 합법적인 사용 사례가 있지만 매우 적습니다. 당신이 변경하려는 경우 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) 이 두 가지는 참조 대응 항목과 거의 동의어이며 호출된 함수가 다른 계약상의 보증이 없는 한 nullptr func 는 param nullptr 을 받지 않을 것임을 보장합니다.

해당 주제에 대한 의견입니다. 이와 같은 경우에 정확성을 증명하는 것은 지옥처럼 어렵고 실수를 저지르기는 너무 쉽습니다. nullptr 대한 포인터 매개변수를 확인하십시오. 장기적으로 벌레를 찾기 힘든 고통과 고통을 덜어줄 것입니다. 그리고 검사 비용에 관해서는 매우 저렴하며 컴파일러에 내장된 정적 분석이 이를 관리할 수 있는 경우 옵티마이저가 이를 무시합니다. MSVC용 링크 타임 코드 생성 또는 GCC용 WOPR(내 생각에는)을 켜면 프로그램 전체에서, 즉 소스 코드 모듈 경계를 넘는 함수 호출에서도 얻을 수 있습니다.

하루가 끝나면 위의 모든 사항은 항상 포인터에 대한 참조를 선호하는 매우 확실한 사례를 만듭니다. 그들은 단지 모든 라운드에서 더 안전합니다.


dgnuff

  • 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

이는 함수가 실수로 전달된 인수를 변경할 수 없도록 보장하기 위해 주로 함수 서명에서 사용하기 위한 것입니다.


blue_note

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

Undefined Behavior

쉽게 기억하려면:

const가 * 앞에 있으면 값은 일정합니다.

const가 * 뒤에 있으면 주소는 상수입니다.

const가 * 전후에 모두 사용 가능하면 값과 주소가 모두 일정합니다.

예

  1. 정수 * const var; //여기서 주소는 상수입니다.

  2. int const * var; //여기서 값은 상수입니다.

  3. int const * const var; // 값과 주소는 모두 상수입니다.


MoBaShiR

  1. const int* - 상수 int 개체에 대한 포인터입니다.

포인터 값을 변경할 수 있습니다. 포인터가 가리키는 int 개체의 값을 변경할 수 없습니다.

  1. const int * const - 상수 int 객체에 대한 상수 포인터.

포인터의 값이나 포인터가 가리키는 int 개체의 값을 변경할 수 없습니다.

  1. int const * - 상수 int 객체에 대한 포인터.

이 문은 1과 같습니다. const int* - 포인터의 값은 변경할 수 있지만 포인터가 가리키는 int

실제로 네 번째 옵션이 있습니다.

  1. int * const int 객체에 대한 상수 포인터.

포인터가 가리키는 개체의 값은 변경할 수 있지만 포인터 자체의 값은 변경할 수 없습니다. 포인터는 항상 같은 가리 킵니다 int 개체 만이이 값 int 객체는 변경 될 수 있습니다.

특정 유형의 C 또는 C++ 구성을 결정하려면 David Anderson이 만든 시계 방향/나선형 규칙을 사용할 수 있습니다. 그러나 Ross J. Anderson이 만든 Anderson's Rule 과 혼동해서는 안 됩니다.


RobertS supports Monica Cellio

간단한 니모닉:

type 포인터 <- * -> 포인터 name

int *i i 의 역참조는 int "라고 선언하는 것으로 생각하고 싶습니다. 이러한 의미에서, const int *i "의 의미 DEREF i 이다 const int 동안" int *const i 수단 "의 DEREF const i 이다 int ".

(이렇게 생각하는 것의 한 가지 위험은 사람들이 싫어하거나 허용하지 않을 수 있는 int const *i


l.k

많은 사람들이 올바르게 답변했습니다. 여기에 잘 정리하고 주어진 답변에 누락된 추가 정보를 넣을 것입니다.

Const는 한정자라고도 하는 C 언어의 키워드입니다. Const는 값이 변경되지 않도록 지정하기 위해 모든 변수 선언에 적용할 수 있습니다.

 const int a=3,b; a=4; // give error b=5; // give error as b is also const int you have to intialize while declaring itself as no way to assign it afterwards.

읽는 방법 ?

오른쪽에서 왼쪽으로 읽기만 하면 모든 문장이 원활하게 작동합니다.

3가지 주요 사항

 type a. p is ptr to const int type b. p is const ptr to int type c. p is const ptr to const int

[오류]

 if * comes before int

두 가지 유형

 1. const int * 2. const const int *

우리는 먼저 본다

주요 유형 1. const int *

3곳에 3가지 물건을 배열하는 방법 3!=6

NS. * 시작 시

 *const int p [Error] *int const p [Error]

ii. 시작 시 const

 const int *p type a. p is ptr to const int const *int p [Error]

iii. 시작 시 int

 int const *p type a. int * const p type b. p is const ptr to int

메이저 타입 2. const const int *

2가 비슷한 4곳에 4가지 물건을 배열하는 방법 4!/2!=12

NS. * 시작 시

 * int const const p [Error] * const int const p [Error] * const const int p [Error]

ii. 시작 시 int

 int const const *p type a. p is ptr to const int int const * const p type c. p is const ptr to const int int * const const p type b. p is const ptr to int

iii. 시작 시 const

 const const int *p type a. const const * int p [Error] const int const *p type a. const int * const p type c. const * int const p [Error] const * const int p [Error]

모두를 하나로 압축

를 입력합니다. p는 ptr에서 const int로 (5)

 const int *p int const *p int const const *p const const int *p const int const *p

유형 b. p는 const ptr에서 int로 (2)

 int * const p int * const const p;

유형 다. p는 const ptr에서 const int로 (2)

 int const * const p const int * const p

약간의 계산

 1. const int * p total arrangemets (6) [Errors] (3) 2. const const int * p total arrangemets (12) [Errors] (6)

리틀 엑스트라

정수 상수 * p, p2 ;

 here p is ptr to const int (type a.) but p2 is just const int please note that it is not ptr

정수 * const p,p2 ;

 similarly here p is const ptr to int (type b.) but p2 is just int not even cost int

int const * const p,p2 ;

 here p is const ptr to const int (type c.) but p2 is just const int.

완성 된


Abhishek Mane

출처 : http:www.stackoverflow.com/questions/1143262/what-is-the-difference-between-const-int-const-int-const-and-int-const

반응형

'etc. > StackOverFlow' 카테고리의 다른 글

목록에서 상속하지 않는 이유<T> ?  (0) 2022.02.08
React JSX 내부 루프  (0) 2022.02.08
C#에서 [Flags] Enum Attribute는 무엇을 의미합니까?  (0) 2022.02.08
Java 'for each' 루프는 어떻게 작동합니까?  (0) 2022.02.08
"javascript:void(0)"은(는) 무슨 뜻인가요?  (0) 2022.02.08

'etc./StackOverFlow'의 다른글

  • 현재글const int*, const int * const 및 int const *의 차이점은 무엇입니까?

관련글

댓글

티스토리툴바