형변환

클래스에서 암시적 변환

암시적 변환은 값이 호환되는 유형으로 복사될 때 자동으로 수행됩니다. 예를 들어:

short a=2000;
int b;
b=a;

여기서 의 값은 명시적 연산자 없이 에서 로 a승격됩니다 . 이것을 표준 변환 이라고 합니다. 표준 변환은 기본 데이터 유형에 영향을 미치며 숫자 유형( to , to , to ...), to 또는 from 및 일부 포인터 변환 간의 변환을 허용합니다. 더 작은 정수 유형에서 로 또는 from으로 변환 하는 것을 승격 이라고 하며 대상 유형에서 정확히 동일한 값을 생성하도록 보장됩니다. 산술 유형 간의 다른 변환이 항상 동일한 값을 정확하게 나타낼 수 있는 것은 아닙니다.shortintshortintintfloatdoubleintbool

intdoublefloat

• 음의 정수 값이 부호 없는 유형으로 변환되면 결과 값은 2의 보수 비트 표현에 해당합니다(즉, -1유형으로 표현할 수 있는 가장 큰 값이 되고 -2두 번째로 큰 값이 ...).
• 0 (숫자 유형의 경우) 및 널 포인터 (포인터 유형의 경우 )와 동등 bool하다고 간주 하는 변환 는 다른 모든 값과 동일하며 에 해당하는 값으로 변환됩니다 .falsetrue1
• 부동 소수점 유형에서 정수 유형으로 변환하는 경우 값이 잘립니다(소수 부분이 제거됨). 결과가 유형별로 표현할 수 있는 값의 범위를 벗어나면 변환으로 인해 정의되지 않은 동작 이 발생 합니다.
• 그렇지 않고 변환이 같은 종류의 숫자 유형(정수에서 정수로 또는 부동에서 부동으로) 간 변환인 경우 변환은 유효하지만 값은 구현에 따라 다르며 이식 가능하지 않을 수 있습니다.

이러한 변환 중 일부는 컴파일러가 경고와 함께 신호를 보낼 수 있는 정밀도 손실을 의미할 수 있습니다. 이 경고는 명시적 변환으로 피할 수 있습니다.

기본이 아닌 유형의 경우 배열 및 함수는 암시적으로 포인터로 변환되고 포인터는 일반적으로 다음 변환을 허용합니다.

• 널 포인터 는 모든 유형의 포인터로 변환될 수 있습니다.
• 모든 유형에 대한 포인터는 void포인터로 변환될 수 있습니다.
• 포인터 업캐스트 : 파생 클래스에 대한 포인터는 해당 또는 자격 을 수정하지 않고 액세스 가능 하고 모호하지 않은 기본 클래스 의 포인터로 변환될 수 있습니다.constvolatile
•  

클래스를 사용한 암시적 변환

클래스의 세계에서 암시적 변환은 세 가지 멤버 함수를 통해 제어할 수 있습니다.

• 단일 인수 생성자: 특정 유형에서 암시적 변환을 허용하여 개체를 초기화합니다.
• 할당 연산자: 할당 에서 특정 유형의 암시적 변환을 허용합니다.
• 유형 캐스트 ​​연산자: 특정 유형으로의 암시적 변환을 허용합니다.

예를 들어:

// implicit conversion of classes:
#include <iostream>
using namespace std;

class A {};

class B {
public:
  // conversion from A (constructor):
  B (const A& x) {}
  // conversion from A (assignment):
  B& operator= (const A& x) {return *this;}
  // conversion to A (type-cast operator)
  operator A() {return A();}
};

int main ()
{
  A foo;
  B bar = foo;    // calls constructor
  bar = foo;      // calls assignment
  foo = bar;      // calls type-cast operator
  return 0;
}

type-cast 연산자는 특정 구문을 사용합니다. operator키워드 다음에 대상 유형과 빈 괄호 세트가 오는 것을 사용합니다. 반환 유형은 대상 유형이므로 operator키워드 앞에 지정되지 않습니다.

명시적 형변환

함수 호출에서 C++는 각 인수에 대해 하나의 암시적 변환이 발생하도록 허용합니다. 이것은 항상 의도한 것이 아니기 때문에 수업에서 다소 문제가 될 수 있습니다. 예를 들어, 마지막 예제에 다음 함수를 추가하면:

void fn (B arg) {}

이 함수는 type 의 인수를 취하지 B만 type 의 객체를 A인수로 사용하여 호출할 수도 있습니다.

fn (foo);

이것은 의도한 것일 수도 있고 아닐 수도 있습니다. 그러나 어떤 경우에도 영향을 받는 생성자를 explicit키워드로 표시하여 방지할 수 있습니다.

// explicit:
#include <iostream>
using namespace std;

class A {};

class B {
public:
  explicit B (const A& x) {}
  B& operator= (const A& x) {return *this;}
  operator A() {return A();}
};

void fn (B x) {}

int main ()
{
  A foo;
  B bar (foo);
  bar = foo;
  foo = bar;
  
//  fn (foo);  // not allowed for explicit ctor.
  fn (bar);  

  return 0;
}

또한 로 표시된 생성자 explicit는 할당과 유사한 구문으로 호출할 수 없습니다. 위의 예에서는 다음 을 사용하여 bar구성할 수 없습니다.

B bar = foo;

유형 캐스트 ​​멤버 함수(이전 섹션에서 설명한 것)는 로 지정할 수도 있습니다 explicit. 이것은 explicit-지정된 생성자가 대상 유형에 대해 수행하는 것과 동일한 방식으로 암시적 변환을 방지합니다.

 

명시적 형변환

C++는 강력한 형식의 언어입니다. 많은 변환, 특히 값의 다른 해석을 암시하는 변환에는 C++에서 type-casting 으로 알려진 명시적 변환이 필요합니다 . 제네릭 타입 캐스팅을 위한 두 가지 주요 구문이 있습니다: 기능적 및 c-like :

double x = 10.3;
int y;
y = int (x);    // functional notation
y = (int) x;    // c-like cast notation

이러한 일반적인 형식 캐스팅의 기능은 기본 데이터 형식에 대한 대부분의 요구 사항에 충분합니다. 그러나 이러한 연산자는 클래스와 클래스에 대한 포인터에 무차별적으로 적용될 수 있으며, 이는 구문적으로 정확하지만 런타임 오류를 일으킬 수 있는 코드로 이어질 수 있습니다. 예를 들어 다음 코드는 오류 없이 컴파일됩니다.

// class type-casting
#include <iostream>
using namespace std;

class Dummy {
    double i,j;
};

class Addition {
    int x,y;
  public:
    Addition (int a, int b) { x=a; y=b; }
    int result() { return x+y;}
};

int main () {
  Dummy d;
  Addition * padd;
  padd = (Addition*) &d;
  cout << padd->result();
  return 0;
}

프로그램은 에 대한 포인터를 선언 Addition하지만 명시적 유형 캐스팅을 사용하여 관련되지 않은 다른 유형의 개체에 대한 참조를 할당합니다.

padd = (Addition*) &d;

무제한 명시적 유형 캐스팅을 사용하면 포인터가 가리키는 유형과 관계없이 모든 포인터를 다른 포인터 유형으로 변환할 수 있습니다. 멤버에 대한 후속 호출 result은 런타임 오류 또는 기타 예상치 못한 결과를 생성합니다.

클래스 간의 이러한 유형의 변환을 제어하기 위해 dynamic_cast, reinterpret_cast및 . 형식은 꺾쇠괄호( )로 묶인 새 형식을 따르고 바로 뒤에 괄호로 변환할 표현식을 따릅니다. 이러한 표현식에 해당하는 기존 유형 변환은 다음과 같습니다. 그러나 각각 고유한 특성이 있습니다.static_castconst_cast<>

dynamic_cast <new_type> (expression)
reinterpret_cast <new_type> (expression)
static_cast <new_type> (expression)
const_cast <new_type> (expression)



(new_type) expression
new_type (expression)

 

dynamic_cast

dynamic_cast클래스에 대한 포인터 및 참조(또는 와 함께 void*)에만 사용할 수 있습니다. 그 목적은 형식 변환의 결과가 대상 포인터 형식의 유효한 완전한 개체를 가리키도록 하는 것입니다. 여기에는 암시적 변환 과 동일한 방식으로 포인터 업캐스트

(포인터에서 파생에서 포인터로 변환)가 자연스럽게 포함됩니다 . 그러나 지적된 객체가 대상 유형의 유효한 완전한 객체인 경우에만 (가상 멤버가 있는) 다형성 클래스를 다운캐스트 (베이스에 대한 포인터에서 파생된 포인터로 변환) 할 수도 있습니다 . 예를 들어:

// dynamic_cast
#include <iostream>
#include <exception>
using namespace std;

class Base { virtual void dummy() {} };
class Derived: public Base { int a; };

int main () {
  try {
    Base * pba = new Derived;
    Base * pbb = new Base;
    Derived * pd;

    pd = dynamic_cast<Derived*>(pba);
    if (pd==0) cout << "Null pointer on first type-cast.\n";

    pd = dynamic_cast<Derived*>(pbb);
    if (pd==0) cout << "Null pointer on second type-cast.\n";

  } catch (exception& e) {cout << "Exception: " << e.what();}
  return 0;
}

호환성 참고: 이 유형 은 동적 유형을 추적하기 위해 RTTI(런타임 유형 정보)dynamic_cast 가 필요합니다 . 일부 컴파일러는 이 기능을 기본적으로 비활성화된 옵션으로 지원합니다. 이러한 유형에서 제대로 작동하려면 를 사용하여 런타임 유형 검사를 위해 활성화해야 합니다 .dynamic_cast

 

Base*위의 코드는 ( pba및 pbb) 유형의 포인터 개체에서 유형의 포인터 개체로 두 개의 동적 캐스트를 수행하려고 시도 Derived*하지만 첫 번째 것만 성공합니다. 각각의 초기화를 확인하십시오.

Base * pba = new Derived;
Base * pbb = new Base;

둘 다 형식의 포인터이지만 Base*실제로 pba는 형식의 개체 를 가리키는 Derived반면 형식 pbb의 개체를 가리킵니다 Base. 따라서 각각의 유형 변환이 를 사용하여 수행될 때 dynamic_cast는 pbaclass 의 전체 개체를 가리키는 Derived반면 pbb는 class Base의 불완전한 개체인 class 의 개체를 가리킵니다 Derived. 이전 예제의 두 번째 변환에서와 같이 필수 클래스의 완전한 개체가 아니기 때문에 포인터를 캐스팅할 수 없는

경우 실패를 나타내기 위해 null 포인터 를 반환합니다. 참조 형식으로 변환하는 데 사용되며 변환이 불가능한 경우 형식 예외가 대신 throw됩니다.dynamic_castdynamic_castbad_cast

dynamic_cast포인터에서 허용되는 다른 암시적 캐스트도 수행할 수 있습니다 void*.

 

static_cast

static_cast업캐스트 (포인터에서 파생에서 베이스로 포인터 로)뿐만 아니라 다운캐스트 (포인터에서 베이스에서 파생된 포인터로) 뿐 아니라 관련 클래스에 대한 포인터 간의 변환을 수행할 수 있습니다 . 변환 중인 개체가 실제로 대상 유형의 전체 개체인지 확인하기 위해 런타임 중에 검사가 수행되지 않습니다. 따라서 변환이 안전한지 확인하는 것은 프로그래머에게 달려 있습니다. 반면에 의 형식 안전성 검사 오버헤드가 발생하지 않습니다 dynamic_cast.

class Base {};
class Derived: public Base {};
Base * a = new Base;
Derived * b = static_cast<Derived*>(a);

b이것은 클래스의 불완전한 개체를 가리키고 역참조되는 경우 런타임 오류로 이어질 수 있지만 유효한 코드 입니다.

따라서 static_cast암시적으로 허용되는 변환뿐만 아니라 반대 변환도 클래스에 대한 포인터로 수행할 수 있습니다.

static_cast또한 암시적으로 허용되는 모든 변환(클래스에 대한 포인터가 있는 변환뿐 아니라)을 수행할 수 있으며 이와 반대의 작업도 수행할 수 있습니다. 다음을 수행할 수 있습니다.

• void*에서 임의의 포인터 유형으로 변환 합니다. 이 경우 void*동일한 포인터 유형에서 변환하여 값을 얻은 경우 결과 포인터 값이 동일함을 보장합니다.
• 정수, 부동 소수점 값 및 열거형 유형을 열거형 유형으로 변환합니다.

또한 static_cast다음을 수행할 수도 있습니다.

• 단일 인수 생성자 또는 변환 연산자를 명시적으로 호출합니다.
• rvalue 참조 로 변환합니다 .
• enum class값을 정수 또는 부동 소수점 값으로 변환 합니다.
• 모든 유형을 로 변환 void하고 값을 평가하고 버립니다.

reinterpret_cast

reinterpret_cast관련되지 않은 클래스를 포함하여 모든 포인터 유형을 다른 포인터 유형으로 변환합니다. 연산 결과는 한 포인터에서 다른 포인터로 값의 간단한 이진 복사본입니다. 모든 포인터 변환이 허용됩니다. 가리키는 내용이나 포인터 유형 자체가 검사되지 않습니다.

또한 정수 유형으로 또는 정수 유형에서 포인터를 캐스팅할 수 있습니다. 이 정수 값이 포인터를 나타내는 형식은 플랫폼에 따라 다릅니다. 유일한 보장은 포인터를 완전히 포함하기에 충분히 큰 정수 유형(예: intptr_t)으로 캐스팅된 포인터가 유효한 포인터로 다시 캐스팅될 수 있다는 것입니다.

수행할 수 있지만 수행할 수 없는 reinterpret_cast변환static_cast유형의 이진 표현을 재해석하는 것을 기반으로 하는 저수준 작업으로, 대부분의 경우 시스템 고유의 코드가 되어 이식성이 없습니다. 예를 들어:

class A { /* ... */ };
class B { /* ... */ };
A * a = new A;
B * b = reinterpret_cast<B*>(a);

b이 코드 는 완전히 관련이 없고 호환되지 않을 가능성이 있는 클래스의 개체를 가리 키기 때문에 별로 의미가 없지만 컴파일됩니다 . 역참조 b는 안전하지 않습니다.

 

const_cast

이 유형의 캐스팅은 포인터가 가리키는 객체의 일관성을 설정하거나 제거하도록 조작합니다. 예를 들어, const가 아닌 인수를 기대하는 함수에 const 포인터를 전달하려면:

// const_cast
#include <iostream>
using namespace std;

void print (char * str)
{
  cout << str << '\n';
}

int main () {
  const char * c = "sample text";
  print ( const_cast<char *> (c) );
  return 0;
}

print위의 예제는 함수 가 가리키는 객체에 쓰지 않기 때문에 작동이 보장됩니다 . 그러나 실제로 쓰기 위해 뾰족한 객체의 constness를 제거하면 정의되지 않은 동작 이 발생 합니다.

 

typeid

typeid표현식의 유형을 확인할 수 있습니다. 이 연산자는 표준 헤더에 정의된 유형의 상수 개체에 대한 참조를 반환합니다 . 에서 반환된 값은 연산자를 사용하여 반환된 다른 값과 비교할 수 있으며 또는 해당 멤버 를 사용하여 데이터 형식 또는 클래스 이름을 나타내는 null로 끝나는 문자 시퀀스를 얻는 데 사용할 수 있습니다 .

typeid (expression)

type_info<typeinfo>typeidtypeid==!=name()

 

// typeid
#include <iostream>
#include <typeinfo>
using namespace std;

int main () {
  int * a,b;
  a=0; b=0;
  if (typeid(a) != typeid(b))
  {
    cout << "a and b are of different types:\n";
    cout << "a is: " << typeid(a).name() << '\n';
    cout << "b is: " << typeid(b).name() << '\n';
  }
  return 0;
}

typeid가 클래스에 적용될 때 typeidRTTI를 사용하여 동적 개체 유형을 추적합니다. 유형이 다형성 클래스인 표현식에 가 적용될 때 typeid결과는 가장 많이 파생된 완전한 객체의 유형입니다.

// typeid, polymorphic class
#include <iostream>
#include <typeinfo>
#include <exception>
using namespace std;

class Base { virtual void f(){} };
class Derived : public Base {};

int main () {
  try {
    Base* a = new Base;
    Base* b = new Derived;
    cout << "a is: " << typeid(a).name() << '\n';
    cout << "b is: " << typeid(b).name() << '\n';
    cout << "*a is: " << typeid(*a).name() << '\n';
    cout << "*b is: " << typeid(*b).name() << '\n';
  } catch (exception& e) { cout << "Exception: " << e.what() << '\n'; }
  return 0;
}

a is: 클래스 베이스 *
b는: 클래스 베이스 *
*a는: 클래스 베이스
*b: 파생된 클래스

참고: 멤버가 반환하는 문자열은 name컴파일러 type_info및 라이브러리의 특정 구현에 따라 다릅니다. 이 출력을 생성하는 데 사용되는 컴파일러에서와 같이 반드시 일반적인 유형 이름을 가진 단순한 문자열일 필요는 없습니다. 포인터에 대해 고려하는 유형이 어떻게 포인터 유형 자체

인지 주목하십시오 ( 및 둘 다 유형 임). 그러나 가 객체에 적용되면( 및 와 같은 ) 동적 유형(즉, 가장 많이 파생된 완전한 객체의 유형)이 생성됩니다. 평가 되는 형식 이 역참조 연산자( )가 앞에 오는 포인터 이고 이 포인터에 null 값이 있으면 예외 가 발생합니다.typeidabclass Base *typeid*a*btypeid

typeid*typeidbad_typeid