사용자 정의 변환(C++/CLI)
형식 변환에서 참조 또는 값 형식 이거나 참조 형식 인스턴스의 경우 사용자 정의 변환 (UDC)이이 섹션에 설명 합니다.
암시적 변환과 명시적 변환
사용자 정의 변환에는 암시적 또는 명시적 수 있습니다.UDC를 변환 정보의 손실이 되지 않으면 암시적 이어야 합니다.그렇지 않은 경우 명시적 UDC는 정의 되어야 합니다.
네이티브 클래스를 참조 또는 값 형식을 변환 하는 기본 클래스 생성자를 사용할 수 있습니다.
변환에 대 한 자세한 내용은 Boxing(C++ 구성 요소 확장) 및 표준 변환.
// mcpp_User_Defined_Conversions.cpp
// compile with: /clr
#include "stdio.h"
ref class R;
class N;
value class V {
static operator V(R^) {
return V();
}
};
ref class R {
public:
static operator N(R^);
static operator V(R^) {
System::Console::WriteLine("in R::operator N");
return V();
}
};
class N {
public:
N(R^) {
printf("in N::N\n");
}
};
R::operator N(R^) {
System::Console::WriteLine("in R::operator N");
return N(nullptr);
}
int main() {
// Direct initialization:
R ^r2;
N n2(r2); // direct initialization, calls constructor
static_cast<N>(r2); // also direct initialization
R ^r3;
// ambiguous V::operator V(R^) and R::operator V(R^)
// static_cast<V>(r3);
}
Output
연산자 변환에서
연산자 변환에서 연산자가 정의 된 클래스의 개체에서 다른 클래스의 개체를 만듭니다.
표준 c + +의 변환 연산자를 지원 하지 않습니다. 표준 c + + 생성자를이 용도로 사용합니다.그러나 CLR 형식을 사용 하는 경우 Visual C++ 제공 구문 지원에서 변환 연산자를 호출 합니다.
물론 다른 CLS 규격 언어와 상호 운용 하려면 각 단항 사용자 정의 생성자는 지정 된 클래스에 대 한 해당 변환에서 사용 하 여 연산자를 배치 하려는 경우도 있습니다.
변환에서 연산자:
함수를 정적으로 정의 됩니다.
정밀도 손실이 없을 때 (예를 들어 short에서 int와 같은 정밀도 손실 되지 않습니다 변환) 암시적 또는 명시적 일 수 있습니다.
포함 하는 클래스의 개체를 반환 합니다.
없어야 합니다 "에서" 형식으로 유일한 매개 변수 형식입니다.
다음 샘플에서는 암시적 및 명시적 "변환-"에서 사용자 정의 변환 (UDC) 연산자를 보여 줍니다.
// clr_udc_convert_from.cpp
// compile with: /clr
value struct MyDouble {
double d;
MyDouble(int i) {
d = static_cast<double>(i);
System::Console::WriteLine("in constructor");
}
// Wrap the constructor with a convert-from operator.
// implicit UDC because conversion cannot lose precision
static operator MyDouble (int i) {
System::Console::WriteLine("in operator");
// call the constructor
MyDouble d(i);
return d;
}
// an explicit user-defined conversion operator
static explicit operator signed short int (MyDouble) {
return 1;
}
};
int main() {
int i = 10;
MyDouble md = i;
System::Console::WriteLine(md.d);
// using explicit user-defined conversion operator requires a cast
unsigned short int j = static_cast<unsigned short int>(md);
System::Console::WriteLine(j);
}
Output
변환 연산자
변환 연산자에는 연산자는 다른 개체에 정의 된 클래스의 개체를 변환 합니다.다음 샘플에서는 암시적으로 변환 하려면 사용자 정의 변환 연산자를 보여 줍니다.
// clr_udc_convert_to.cpp
// compile with: /clr
using namespace System;
value struct MyInt {
Int32 i;
// convert MyInt to String^
static operator String^ ( MyInt val ) {
return val.i.ToString();
}
MyInt(int _i) : i(_i) {}
};
int main() {
MyInt mi(10);
String ^s = mi;
Console::WriteLine(s);
}
Output
명시적 사용자 정의 변환 하려면 변환 연산자는 어떤 방식으로든에서 데이터를 잠재적으로 손실 변환에 적합 합니다.명시적 변환 연산자를 호출 하는 캐스트를 사용 해야 합니다.
// clr_udc_convert_to_2.cpp
// compile with: /clr
value struct MyDouble {
double d;
// convert MyDouble to Int32
static explicit operator System::Int32 ( MyDouble val ) {
return (int)val.d;
}
};
int main() {
MyDouble d;
d.d = 10.3;
System::Console::WriteLine(d.d);
int i = 0;
i = static_cast<int>(d);
System::Console::WriteLine(i);
}
Output
제네릭 클래스를 변환 하려면
제네릭 클래스를 T로 변환
// clr_udc_generics.cpp
// compile with: /clr
generic<class T>
public value struct V {
T mem;
static operator T(V v) {
return v.mem;
}
void f(T t) {
mem = t;
}
};
int main() {
V<int> v;
v.f(42);
int i = v;
i += v;
System::Console::WriteLine(i == (42 * 2) );
}
Output
변환 생성자 형식을 사용 하 여 개체를 만듭니다.변환 생성자 직접 초기화를 이라고 합니다. 캐스트 변환 생성자를 호출 하지 않습니다.변환 생성자는 기본적으로 CLR 형식에 대 한 명시적입니다.
// clr_udc_converting_constructors.cpp
// compile with: /clr
public ref struct R {
int m;
char c;
R(int i) : m(i) { }
R(char j) : c(j) { }
};
public value struct V {
R^ ptr;
int m;
V(R^ r) : ptr(r) { }
V(int i) : m(i) { }
};
int main() {
R^ r = gcnew R(5);
System::Console::WriteLine( V(5).m);
System::Console::WriteLine( V(r).ptr);
}
Output
이 코드 예제에서는 암시적으로 정적 변환 하는 함수는 명시적 변환 생성자와 동일 하지 않습니다.
public value struct V {
int m;
V(int i) : m(i) {}
static operator V(int i) {
V v(i*100);
return v;
}
};
public ref struct R {
int m;
R(int i) : m(i) {}
static operator R^(int i) {
return gcnew R(i*100);
}
};
int main() {
V v(13); // explicit
R^ r = gcnew R(12); // explicit
System::Console::WriteLine(v.m);
System::Console::WriteLine(r->m);
// explicit ctor can't be called here: not ambiguous
v = 5;
r = 20;
System::Console::WriteLine(v.m);
System::Console::WriteLine(r->m);
}
Output