c++강제 형식 변환 에 대한 상세 한 설명

유형 전환 이란 무엇 입 니까?　　
형식 변환 의 의 미 는 하나의 변수의 유형 을 다른 유형 으로 바 꾸 어 이 변수의 표현 방식 을 바 꾸 는 것 이다.유형 을 위해 간단 한 대상 을 다른 대상 으로 바 꾸 려 면 전통 적 인 유형 변환 조작 자 를 사용 할 것 이다.
C 와 C++의 형식 변환
C 중:

(T)element    T（element）

c++중:

reinterpret_cast<T*> (expression)
dynamic_cast<T*>     (expression)
static_cast<T*>      (expression)
const_cast<T*>       (expression)

C++의 네 가지 강제 전환 형식 은 각각 특정한 목적 에 적용 된다. 　　 ・dynamic_캐 스 트 는 주로'안전 한 하향 전환(safe downcasting)'을 수행 하 는 데 사용 된다.즉,하나의 대상 이 계승 시스템 의 특정한 유형 인지 확인 해 야 한 다 는 것 이다.이것 은 낡은 스타일 의 문법 으로 집행 할 수 없 는 유일한 강제 구조 전환 이자 중대 한 운행 시 대가 가 있 을 수 있 는 유일한 강제 구조 전환 이다.          ・static_cast 는 강제 스텔스 변환(예 를 들 어 non-const 대상 이 const 대상 으로 전환 되 고 int 가 double 로 전환 되 는 등)에 사 용 될 수 있 습 니 다.또한 이러한 전환 의 역방향 전환(예 를 들 어 void*지침 은 유형 지침 으로 전환 되 고 기본 지침 은 파생 지침 으로 전환)에 도 사 용 될 수 있 습 니 다.그러나 const 대상 을 non-const 대상 으로 바 꿀 수 없습니다(const 만)캐 스 트 는 할 수 있다),그것 은 C-style 의 전환 에 가장 가깝다.    　   ・const_캐 스 트 는 일반적으로 대상 의 상수 성 을 강제 적 으로 제거 하 는 데 쓰 인 다.그것 은 유일 하 게 이 점 을 할 수 있 는 C++스타일 의 강제 전환 이다. 　　・reinterpret_캐 스 트 는 특별히 밑바닥 의 강제 전환 에 사용 되 어 의존(implementation-dependent)을 실현 한 결과 이다.예 를 들 어 바늘 하 나 를 정수 로 전환 하 는 것 이다.이러한 강제 전환 은 바 텀 코드 외 에 매우 드 물 것 이다.
통속 적 인 해석:
dynamic_cast
보통 기본 클래스 와 파생 클래스 사이 에서 전환 할 때 사용 합 니 다.
static_cast
  일반적인 전환,뭘 써 야 할 지 모 르 면 이 걸 로 하 세 요.
const_cast
주로 const 와 volatile 에 대한 전환
reinterpret_cast
 아무런 관련 이 없 는 변환 을 하 는 데 사용 합 니 다.예 를 들 어 하나의 문자 포인터 가 성형 수로 바 뀌 는 것 입 니 다.
 
 구체 적 인 분석:
1）static_cast(a) 컴 파일 러 는 컴 파일 기간 에 처리 된다.

주소 a 를 유형 T 로 바 꾸 고 T 와 a 는 포인터,인용,산술 유형 또는 매 거 진 유형 이 어야 합 니 다.

표현 식 staticcast(a),a 의 값 을 템 플 릿 에서 지정 한 형식 T 로 변환 합 니 다.

운행 시 전환 과정 에서 유형 검 사 를 하지 않 고 전환 의 안전성 을 확보한다.

　　static_캐 스 트 는 내 장 된 데이터 형식 간 에 서로 변환 할 수 있 으 며,클래스 는 연 결 된 포인터 형식 간 에 만 변환 할 수 있 습 니 다.계승 체계 에서 지침 을 이리 저리 바 꿀 수 는 있 지만 계승 체계 밖의 한 유형

class A { ... };
class B { ... };
class D : public B { ... };
void f(B* pb, D* pd)
{
    D* pd2 = static_cast<D*>(pb);        //    , pb    B   
    B* pb2 = static_cast<B*>(pd);        //    
    A* pa2 = static_cast<A*>(pb);        //  A B      
    ...
}

으로 바 꿀 수 는 없다.
2）dynamic_cast(a) 실행 기간 에 이 전환 이 가능 한 지 확인 합 니 다.

유형 차원 구조 에서 의 향상 을 완성 했다.T 는 포인터,인용 또는 유형 이 없 는 포인터 여야 합 니 다.a.포인터 나 인용 을 결정 하 는 표현 식 이 어야 합 니 다.

　　dynamic_cast 는 포인터 나 인용 에 만 적용 되 며 내 장 된 데이터 형식 은 지원 되 지 않 습 니 다.

표현 식 dynamiccast(a)는 a 값 을 T 형식의 대상 포인터 로 변환 합 니 다.형식 T 가 a 의 기본 형식 이 아니라면 빈 지침 을 되 돌려 줍 니 다.

static 뿐만 아니 라cast 처럼 전환 전후의 두 바늘 이 같은 계승 트 리 에 속 하 는 지 확인 하고 포인터 에 의 해 인 용 된 대상 의 실제 유형 을 확인 하여 전환 이 가능 한 지 확인 해 야 합 니 다.

가능 하 다 면 새 지침 을 되 돌려 주 고 다 중 계승 을 처리 하기 위해 필요 한 오프셋 까지 계산한다.이 두 포인터 사이 에 변환 이 되 지 않 으 면 변환 이 실패 하고 빈 포인터(NULL)로 돌아 갑 니 다.

뚜렷 해,dynamiccast 가 정상적으로 작 동 하려 면 컴 파 일 러 가 런 타임 형식 정보(RTTI)를 지원 해 야 합 니 다.

class Base { virtual dummy() {} };
class Derived : public Base {};
Base* b1 = new Derived;
Base* b2 = new Base;
Derived* d1 = dynamic_cast<Derived *>(b1);          // succeeds
Derived* d2 = dynamic_cast<Derived *>(b2);          // fails: returns 'NULL'

3）const_cast(a)컴 파일 러 가 컴 파일 기간 에 처 리 됩 니 다.

      형식 중의 상수 를 제거 합 니 다.const 나 불안정 한 주소 변경 수 를 제외 하고 T 와 a 는 같은 유형 이 어야 합 니 다.

      표현 식 constcast(a)는 한 클래스 에서 다음 과 같은 속성 을 제거 하 는 데 사 용 됩 니 다:const,volatile,그리고unaligned。

      자체 정의 시 const 의 유형 에 대해 서 는 const 성 을 제거 하 더 라 도 이 내용 을 조작 할 때 조심해 야 합 니 다.r 만 w 로 조작 할 수 있 습 니 다.그렇지 않 으 면 오류 가 발생 할 수 있 습 니 다.

      const_캐 스 트 작업 은 다른 종류 에서 변환 할 수 없습니다.반대로,그것 은 단지 그것 이 작용 하 는 표현 식 을 상수 로 변환 할 뿐이다.이것 은 원래 const 형식 이 아 닌 데 이 터 를 const 형식 으로 변환 하거나 const 속성 을 제거 할 수 있 습 니 다.

class A { ... };
void f()
{
    const A *pa = new A;//const  
    A *pb;// const  
    //pb = pa; //      ，   const        const  
    pb = const_cast<A*>(pa); //   OK 
    ...
}
const char* p = "123"; 
char* c = const_cast<char*>(p); 
c[0] = 1;   //          const ，                  。

4）reinterpret_cast(a)컴 파일 러 가 컴 파일 기간 에 처 리 됩 니 다.

모든 지침 은 다른 유형의 지침 으로 바 꿀 수 있 습 니 다.T 는 지침,인용,산술 유형,함 수 를 가리 키 는 지침 이나 같은 구성원 을 가리 키 는 지침 이 어야 합 니 다.

표현 식 reinterpretcast(a)는 char*에서 int*또는 One 에 사용 할 수 있 습 니 다.class*부터 Unrelated 까지class*등 이와 같은 전환 이 므 로 안전 하지 않 을 수 있 습 니 다.4567918)

class A { ... };
class B { ... };
void f()
{
    A* pa = new A;
    void* pv = reinterpret_cast<A*>(pa);
    // pv           B   ，        
    ...
}