c++에서 const 의 사용 에 대한 상세 한 설명

Const 는 C++에서 자주 사용 하 는 형식 수정자 입 니 다.일반적인 유형 은 형식 수정자 const 를 사용 하여 설명 하 는 유형 을 말 합 니 다.일반적인 유형의 변수 나 대상 의 값 은 업데이트 되 지 않 습 니 다.
1.상수(1)const 수식 변 수 를 정의 하고 다음 과 같은 두 가지 정의 형식 은 본질 적 으로 같다.그 의 미 는 const 가 수식 하 는 유형 이 TYPE 인 변수 value 는 변 할 수 없다 는 것 이다.
 TYPE const ValueName = value;      const TYPE ValueName = value;
(2)const 를 외부 연결 로 바 꾸 고 전역 으로 확대 하 는 역할 을 합 니 다.컴 파일 할 때 메모 리 를 할당 하고 초기 화 하지 않 고 성명 으로 만 할 수 있 습 니 다.컴 파일 러 는 프로그램의 다른 곳 에서 정 의 를 내 렸 다 고 생각 합 니 다.
     extend const int ValueName = value;
2.포인터 사용 CONST(1)포인터 자체 상수 불가 변     (char*) const pContent;      const (char*) pContent;
(2)포인터 가 가리 키 는 내용 은 상수 불변 이다     const (char) *pContent;      (char) const *pContent;
(3)둘 다 변 하지 않 는 다.      const char* const pContent;
(4)그 중에서 차이 점 이 있 습 니 다.*번 호 를 따라 선 을 긋 습 니 다.만약 에 const 가*의 왼쪽 에 있 으 면 const 는 포인터 가 가리 키 는 변 수 를 수식 하 는 것 입 니 다.즉,포인터 가 상수 로 가리 키 는 것 입 니 다.만약 const 가*의 오른쪽 에 있다 면 const 는 포인터 자 체 를 수식 하 는 것 입 니 다.즉,포인터 자체 가 상수 입 니 다.
3.함수 에서 CONST 사용
(1)const 수식 함수 파라미터 a.전 달 된 매개 변 수 는 함수 내 에서 바 꿀 수 없습니다(의미 가 없습니다.Var 자체 가 형 삼 이기 때 문 입 니 다)
void function(const int Var);
b.매개 변수 포인터 가 가리 키 는 내용 은 상수 로 변 할 수 없습니다.
void function(const char* Var);
c.매개 변수 포인터 자체 가 상수 로 변 하지 않 습 니 다(의미 도 없습니다.char*Var 도 형 삼 이기 때 문 입 니 다)
void function(char* const Var);
d.매개 변 수 는 인용 입 니 다.효율 을 높이 고 수정 을 방지 하기 위해 서 입 니 다.인용 매개 변 수 를 수식 할 때:
void function(const Class& Var); //인용 매개 변 수 는 함수 내 에서 변경 할 수 없습니다.
void function(const TYPE& Var); //인용 매개 변 수 는 함수 내 에서 상수 로 변 할 수 없습니다.
2)const 수식 함수 반환 값    const 수식 함수 반환 값 은 실 용적 인 것 이 많 지 않 습 니 다.그 의 미 는 const 수식 일반 변수 와 지침 의 의미 와 대체적으로 같 습 니 다.    a.const int fun 1()/이것 은 사실 의미 가 없습니다.매개 변수 반환 자체 가 할당 이기 때 문 입 니 다.    b.const int*fun 2()//호출 시 const int*pValue=fun 2();                          //우 리 는 fun 2()를 하나의 변수 로 볼 수 있다.즉,지침 내용 이 변 하지 않 는 다 는 것 이다.    c.int* const fun3()   //호출 시 int*const pValue=fun 2();                          //우 리 는 fun 2()를 하나의 변수 로 볼 수 있다.즉,포인터 자체 가 변 할 수 없다 는 것 이다.
4.클래스 관련 CONST
(1)const 는 구성원 변수 const 수식 류 의 구성원 함 수 를 수식 합 니 다.구성원 상수 가 수정 되 지 않 고 초기 화 목록 에서 만 값 을 부여 할 수 있 습 니 다.    class A    {         …        const int nValue;         //멤버 상수 수정 불가        …        A(int x): nValue(x) { } ; //초기 화 목록 에 만 값 을 부여 할 수 있 습 니 다.     }
(2)const 는 구성원 함수 const 수식 류 의 구성원 함 수 를 수식 합 니 다.이 구성원 함 수 는 클래스 의 비 const 구성원 함 수 를 수정 할 수 없습니다.일반적으로 함수 의 마지막 에 써 서 수식 한다.    class A    {         …       void function()const; //일반 구성원 함수,대상 의 구성원 변 수 를 바 꾸 지 않 습 니 다.                       
//클래스 의 비 const 구성원 함 수 를 호출 할 수 없습니다.}
(3)const 수식 클래스 대상/대상 포인터/대상 참조
•const 수식 류 대상 은 이 대상 이 상수 대상 이 며,그 중 어떤 구성원 도 수정 할 수 없습니다.대상 포인터 와 대상 인용 도 마찬가지다.const 수식 대상,이 대상 의 비 const 구성원 함수 가 호출 되 지 않 습 니 다.비 const 구성원 함수 가 구성원 변 수 를 수정 하려 는 시도 가 있 기 때 문 입 니 다.예 를 들 어

class AAA 
{  
    void func1();  
　　void func2() const;  
}  
const AAA aObj;  
aObj.func1(); //× 
aObj.func2(); //   

const AAA* aObj = new AAA();  
aObj-> func1(); //× 
aObj-> func2(); //   

5.Const 유형 을 비 Const 유형 으로 바 꾸 는 방법
C++는 네 개의 변환 연산 자 를 제공 합 니 다:
•const case (expression)•static_cast (expression)•reinterpret_cast (expression)•dynamic_cast (expression) 
const 사용cast 에서 비 Const 형식 변환 을 진행 합 니 다.  용법:constcast   (expression)이 연산 자 는 형식의 const 나 volatile 속성 을 수정 하 는 데 사 용 됩 니 다.const 나 volatile 수식 외 에 typeid 와 expression 의 유형 은 같 습 니 다.
•상수 포인터 가 비상 포인터 로 바 뀌 었 고 원래 의 대상 을 가리 키 고 있 습 니 다.상수 인용 은 비상 인용 으로 바 뀌 었 고 원래 의 대상 을 가리 키 고 있 습 니 다.상수 대상 이 비상 대상 으로 전환 되다.4567913)물론 우 리 는 아래 의 전통 적 인 방식 으로 대체 할 수 있다.

const int constant = 21; 
const int* const_p = &constant; 
int* modifier = const_cast<int*>(const_p); 
*modifier = 7; 

앞의 코드 에서 이미 보 았 듯 이 우 리 는 constant 을 수정 할 수 없 지만,우 리 는 modifier 를 다시 할당 할 수 있다.
하지만 절차 세 계 는 정말 혼 란 스 러 웠 을 까?저희 가 정말 modifier 를 통 해 constatn 의 값 을 수 정 했 나 요?const 변 수 를 수정 하 는 데 이 터 는 정말 C+const 로 가 는 목적 입 니까?
만약 우리 가 결 과 를 출력 한다 면

const int constant = 21; 
int* modifier = (int*)(&constant); 

constant 은 원래 의 값 을 유지 합 니 다.
그러나 그들 은 확실히 같은 주 소 를 가리 키 고 있 습 니 다.

cout << "constant: "<< constant <<endl; 
cout << "const_p: "<< *const_p <<endl; 
cout << "modifier: "<< *modifier <<endl; 
/** 
constant: 21 
const_p: 7 
modifier: 7 
**/ 

이렇게 하면 const 의 값 을 다시 할당 할 수 있 지만 const 데 이 터 를 다시 할당 하지 마 십시오.