다음을 통해 공유

형식 특성에 대한 컴파일러 지원(C++ 구성 요소 확장)

  • 아티클

컴파일러 지원 종류 특성, 컴파일 타임에 다양 한 특성 형식을 나타냅니다.

모든 런타임

설명

특성 형식 라이브러리를 작성 하는 프로그래머에 게 특히 유용 합니다.

다음 표에서 컴파일러에 의해 지원 되는 형식 특성.모든 입력 특성 반환 false 형식 특성의 이름으로 지정 된 조건이 충족 되지 않을 경우.

(테이블의 설명 열에 코드 예제에만 기록 됩니다 C++/CLI.하지만 해당 형식 성분도에 지 Visual C++ 구성 요소 확장 언급이."플랫폼 유형" 라는 용어를 중 하나를 참조 Windows 런타임 형식 또는 공용 언어 런타임 형식입니다.)

형식 특성

설명

__has_assign(type)

플랫폼 또는 네이티브 형식 복사 할당 연산자가 있는 경우 true를 반환 합니다.

// has_assign.cpp
// compile with: /clr
ref struct R {
   void operator=(R% r) {}
};
int main() {
   System::Console::WriteLine(__has_assign(R));
}

__has_copy(type)

플랫폼 또는 네이티브 형식에 복사 생성자가 있는 경우 true를 반환 합니다.

// has_copy.cpp
// compile with: /clr
ref struct R {
   R(R% r) {}
};
int main() {
   System::Console::WriteLine(__has_copy(R));
}

__has_finalizer(type)

(에 지원 안 함 Visual C++ 구성 요소 확장.) CLR 형식에 종료 자가 있으면 true를 반환 합니다.자세한 내용은 소멸자 및 종료자에서를 참조하십시오.

// has_finalizer.cpp
// compile with: /clr
using namespace System;
ref struct R {
   ~R() {}
protected:
   !R() {}
};
int main() {
   Console::WriteLine(__has_finalizer(R));
}

__has_nothrow_assign(type)

복사 할당 연산자는 빈 예외 사양이 있으면 true를 반환 합니다.

// has_nothrow_assign.cpp
#include <stdio.h>
struct S { 
   void operator=(S& r) throw() {}
};
int main() {
   __has_nothrow_assign(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_nothrow_constructor(type)

기본 생성자는 빈 예외 사양이 있으면 true를 반환 합니다.

// has_nothrow_constructor.cpp
#include <stdio.h>
struct S { 
   S() throw() {}
};
int main() {
   __has_nothrow_constructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_nothrow_copy(type)

복사 생성자가 빈 예외 사양이 있으면 true를 반환 합니다.

// has_nothrow_copy.cpp
#include <stdio.h>
struct S { 
   S(S& r) throw() {}
};
int main() {
   __has_nothrow_copy(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_trivial_assign(type)

간단한, 컴파일러에서 생성 된 할당 연산자는 형식에 있는 경우 true를 반환 합니다.

// has_trivial_assign.cpp
#include <stdio.h>
struct S {};
int main() {
   __has_trivial_assign(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_trivial_constructor(type)

컴파일러 생성 특수 한 생성자는 형식에 있는 경우 true를 반환 합니다.

// has_trivial_constructor.cpp
#include <stdio.h>
struct S {};
int main() {
   __has_trivial_constructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_trivial_copy(type)

사소한, 컴파일러에서 생성 된 복사 생성자는 형식이 면 true를 반환 합니다.

// has_trivial_copy.cpp
#include <stdio.h>
struct S {};
int main() {
   __has_trivial_copy(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_trivial_destructor(type)

사소한, 컴파일러에서 생성 된 소멸자가 있는 경우 true를 반환 합니다.

// has_trivial_destructor.cpp
#include <stdio.h>
struct S {};
int main() {
   __has_trivial_destructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

__has_user_destructor(type)

플랫폼 또는 네이티브 형식은 사용자가 선언한 소멸자가 있는 경우 true를 반환 합니다.

// has_user_destructor.cpp
// compile with: /clr
using namespace System;
ref class R {
   ~R() {}
};
int main() {
   Console::WriteLine(__has_user_destructor(R));
}

__has_virtual_destructor(type)

가상 소멸자가 있는 경우 true를 반환 합니다.

__has_virtual_destructor가상 소멸자의 플랫폼 유형과 플랫폼 유형으로 모든 사용자 정의 소멸자 이기도합니다.

// has_virtual_destructor.cpp
#include <stdio.h>
struct S {
   virtual ~S() {}
};
int main() {
   __has_virtual_destructor(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_abstract(type)

형식이 추상 형식인 경우 true를 반환 합니다.추상 기본 형식에 대 한 자세한 내용은 abstract(C++ 구성 요소 확장).

__is_abstract플랫폼 형식에 대해서도 작동합니다.추상 멤버를 하나 이상 참조 형식과 인터페이스에는 멤버가 적어도 하나는 추상 형식이 같습니다.추상 플랫폼 유형에 대 한 자세한 내용은 다음을 참조 하십시오.추상 클래스 (C++)

// is_abstract.cpp
#include <stdio.h>
struct S {
   virtual void Test() = 0;
};
int main() {
   __is_abstract(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_base_of(base,derived)

두 형식 모두 같은 경우는 첫 번째 두 번째 형식의 기본 클래스의 형식인 경우 true를 반환 합니다.

__is_base_of또한 플랫폼 유형에 대해 작동합니다.예를 들어, 첫 번째 형식인 경우 true 반환 합니다는 interface 클래스(C++ 구성 요소 확장) 및 두 번째 종류의 인터페이스를 구현 합니다.

// is_base_of.cpp
#include <stdio.h>
struct S {};
struct T : public S {};
int main() {
   __is_base_of(S, T) == true ? 
      printf("true\n") : printf("false\n");
   __is_base_of(S, S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_class(type)

기본 클래스 또는 구조체 형식인 경우 true를 반환 합니다.

// is_class.cpp
#include <stdio.h>
struct S {};
int main() {
   __is_class(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_convertible_to(from, to)

첫 번째 유형은 두 번째 형식으로 변환할 수 있는 경우 true를 반환 합니다.

// is_convertible_to.cpp
#include <stdio.h>
struct S {};
struct T : public S {};
int main() {
   S * s = new S;
   T * t = new T;
   s = t;
   __is_convertible_to(T, S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_delegate(type)

True 이면 반환 type 대리자입니다.자세한 내용은 delegate(C++ 구성 요소 확장)를 참조하십시오.

// is_delegate.cpp
// compile with: /clr
delegate void MyDel();
int main() {
   System::Console::WriteLine(__is_delegate(MyDel));
}

__is_empty(type)

형식에 인스턴스 데이터 멤버가 있는 경우 true를 반환 합니다.

// is_empty.cpp
#include <stdio.h>
struct S {
   int Test() {}
   static int i;
};
int main() {
   __is_empty(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_enum(type)

종류는 네이티브 열거형 이면 true를 반환 합니다.

// is_enum.cpp
#include <stdio.h>
enum E { a, b };
struct S {
   enum E2 { c, d };   
};
int main() {
   __is_enum(E) == true ? 
      printf("true\n") : printf("false\n");
   __is_enum(S::E2) == true ? 
      printf("true\n") : printf("false\n");
}

__is_interface_class(type)

플랫폼 인터페이스에 전달 된 경우 true를 반환 합니다.자세한 내용은 interface 클래스(C++ 구성 요소 확장)를 참조하십시오.

// is_interface_class.cpp
// compile with: /clr
using namespace System;
interface class I {};
int main() {
   Console::WriteLine(__is_interface_class(I));
}

__is_pod(type)

생성자 또는 전용 또는 보호 된 비정적 멤버, 없는 기본 클래스 가상 함수가 없는 구조체나 클래스 형식인 경우 true를 반환 합니다.포드는 C++ 표준, 섹션 8.5.1/1을, 9/4 및 3.9/10에 대 한 자세한 내용은 참조 하십시오.

__is_pod기본 형식에 대해 false를 반환 합니다.

// is_pod.cpp
#include <stdio.h>
struct S {};
int main() {
   __is_pod(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_polymorphic(type)

네이티브 형식에 가상 함수가 포함 되어 있는 경우 true를 반환 합니다.

// is_polymorphic.cpp
#include <stdio.h>
struct S {
   virtual void Test(){}
};
int main() {
   __is_polymorphic(S) == true ? 
      printf("true\n") : printf("false\n");
}

__is_ref_array(type)

플랫폼 배열을 전달 하는 경우 true를 반환 합니다.자세한 내용은 배열(C++ 구성 요소 확장)을 참조하십시오.

// is_ref_array.cpp
// compile with: /clr
using namespace System;
int main() {
   array<int>^ x = gcnew array<int>(10);
   Console::WriteLine(__is_ref_array(array<int>));
}

__is_ref_class(type)

참조 클래스를 전달 하는 경우 true를 반환 합니다.사용자 정의 참조 형식에 대 한 자세한 내용은 클래스 및 구조체(C++ 구성 요소 확장).

// is_ref_class.cpp
// compile with: /clr
using namespace System;
ref class R {};
int main() {
   Console::WriteLine(__is_ref_class(Buffer));
   Console::WriteLine(__is_ref_class(R));
}

__is_sealed(type)

플랫폼 또는 네이티브 형식에 전달 된 경우 true를 반환 봉인 표시 합니다.자세한 내용은 sealed(C++ 구성 요소 확장)를 참조하십시오.

// is_sealed.cpp
// compile with: /clr
ref class R sealed{};
int main() {
   System::Console::WriteLine(__is_sealed(R));
}

__is_simple_value_class(type)

가비지 수집 된 힙에 대 한 참조가 들어 있는 값 형식에 전달 된 경우 true를 반환 합니다.사용자 정의 값 형식에 대 한 자세한 내용은 클래스 및 구조체(C++ 구성 요소 확장).

// is_simple_value_class.cpp
// compile with: /clr
using namespace System;
ref class R {};
value struct V {};
value struct V2 {
   R ^ r;   // not a simnple value type
};
int main() {
   Console::WriteLine(__is_simple_value_class(V));
   Console::WriteLine(__is_simple_value_class(V2));
}

__is_union(type)

이 공용 구조체 형식인 경우 true를 반환 합니다.

// is_union.cpp
#include <stdio.h>
union A {
   int i;
   float f;
};
int main() {
   __is_union(A) == true ? 
      printf("true\n") : printf("false\n");
}

__is_value_class(type)

값 형식에 전달 된 경우 true를 반환 합니다.사용자 정의 값 형식에 대 한 자세한 내용은 클래스 및 구조체(C++ 구성 요소 확장).

// is_value_class.cpp
// compile with: /clr
value struct V {};
int main() {
   System::Console::WriteLine(__is_value_class(V));
}

Windows 런타임

설명

__has_finalizer(형식) 종료자가이 플랫폼을 지원 하지 않으므로 형식 특성을 지원 하지 않습니다.

ms177194.collapse_all(ko-kr,VS.110).gif요구 사항

컴파일러 옵션:/ZW

공용 언어 런타임

설명

(이 기능에 대 한 없음 플랫폼별 설명입니다.)

ms177194.collapse_all(ko-kr,VS.110).gif요구 사항

컴파일러 옵션:/clr

ms177194.collapse_all(ko-kr,VS.110).gif예제

예제

다음 코드 예제에서는 클래스 템플릿을 사용 하는 컴파일러 형식 특성에 대 한 노출은 /clr 컴파일.자세한 내용은 Windows 런타임 및 관리되는 템플릿(C++ 구성 요소 확장)를 참조하십시오.

// compiler_type_traits.cpp
// compile with: /clr
using namespace System;

template <class T>
ref struct is_class {
   literal bool value = __is_ref_class(T);
};

ref class R {};

int main () {
   if (is_class<R>::value)
      Console::WriteLine("R is a ref class");
   else
      Console::WriteLine("R is not a ref class");
}

Output

참고 항목

개념

런타임 플랫폼의 구성 요소 확장