[java] C # 및 Java의 제네릭과 C ++의 템플릿의 차이점은 무엇입니까? [닫은]

나는 소리에 목소리를 더하고 일을 명확하게하는 데 찌를 것이다 :

C # Generics를 사용하면 이와 같은 것을 선언 할 수 있습니다.

List<Person> foo = new List<Person>();

그런 다음 컴파일러는 Person목록에 없는 것을 넣지 못하게 합니다.
뒤에서 C # 컴파일러는 List<Person>.NET dll 파일에 넣지 만 런타임에 JIT 컴파일러는 마치 사람들을 포함하기 위해 특별한 목록 클래스를 작성한 것처럼 새로운 코드 세트를 작성하고 빌드합니다 ListOfPerson.

이것의 장점은 정말 빠르다는 것입니다. 캐스팅이나 다른 것들이 없으며 dll에 이것이 List of라는 정보가 포함되어 있기 때문에 Person나중에 리플렉션을 사용하여 그것을 보는 다른 코드는 Person객체 가 포함되어 있음을 알 수 있습니다 (따라서 인텔리전스 등을 얻습니다).

이것의 단점은 오래된 C # 1.0 및 1.1 코드 (제네릭을 추가하기 전에)가 이러한 새로운 것을 이해하지 못하기 List<something>때문에 수동으로 항목을 다시 변환 List하여 상호 운용해야합니다. C # 2.0 이진 코드는 이전 버전과 호환되지 않기 때문에 큰 문제는 아닙니다. 이것이 일어날 유일한 시간은 오래된 C # 1.0 / 1.1 코드를 C # 2.0으로 업그레이드하는 경우입니다.

Java Generics를 사용하면 이와 같은 것을 선언 할 수 있습니다.

ArrayList<Person> foo = new ArrayList<Person>();

표면에서 그것은 동일하게 보이며 정렬됩니다. 컴파일러는 Person목록에 없는 것을 넣지 못하게 합니다.

차이점은 무대 뒤에서 일어나는 일입니다. C #과 달리 Java는 특별한 ListOfPerson것을 만들지 않고 ArrayList항상 Java로 사용되었던 평범한 오래된 것을 사용합니다 . 배열에서 물건을 꺼낼 때 일반적인 Person p = (Person)foo.get(1);캐스팅 댄스는 여전히 수행해야합니다. 컴파일러는 키 누름을 저장하지만 속도 적중 / 캐스팅은 항상 그렇듯이 발생합니다.
사람들이 “Type Erasure”를 언급 할 때 이것이 바로 그들이 말하는 것입니다. 컴파일러는 캐스트를 삽입 한 다음 Person단순히 목록이 아니라는 사실을 ‘삭제’합니다.Object

이 접근법의 장점은 제네릭을 이해하지 못하는 오래된 코드는 신경 쓸 필요가 없다는 것입니다. 그것은 여전히 ArrayList그렇듯이 여전히 낡은 것을 다루고 있습니다. Java 세계에서는 제네릭으로 Java 5를 사용하여 코드 컴파일을 지원하고 이전 1.4 또는 이전 JVM에서 실행되도록했기 때문에 이는 Microsoft에서 더 중요합니다.

단점은 앞서 언급 한 속도 적중이며 ListOfPerson, .class 파일에 들어가는 의사 클래스 또는 이와 유사한 것이 없기 때문에 나중에 볼 코드 (반사 또는 다른 컬렉션에서 가져 오는 경우) 변환 된 위치 등 Object)는 Person다른 배열 목록뿐만 아니라 단지 포함하는 목록이라는 것을 알 수 없습니다 .

C ++ 템플릿을 사용하면 이와 같은 것을 선언 할 수 있습니다

std::list<Person>* foo = new std::list<Person>();

C # 및 Java 제네릭처럼 보이며 원하는 방식으로 작동하지만 뒤에서 다른 일이 발생합니다.

C # 제네릭과 가장 공통적 인 점은 pseudo-classesJava와 같이 유형 정보를 버리는 대신 특수하게 빌드한다는 점 에서 완전히 다른 주전자입니다.

C #과 Java는 모두 가상 머신 용으로 설계된 출력을 생성합니다. Person클래스 가있는 코드를 작성하면 두 가지 경우 모두 클래스에 대한 일부 정보 Person가 .dll 또는 .class 파일에 들어가고 JVM / CLR 이이 작업을 수행합니다.

C ++은 원시 x86 이진 코드를 생성합니다. 모든 것이 객체 가 아니며Person 클래스 에 대해 알아야 할 기본 가상 머신이 없습니다 . 복싱 또는 언 박싱이 없으며 함수는 클래스에 속하거나 실제로 아무것도 필요하지 않습니다.

이 때문에 C ++ 컴파일러는 템플릿을 사용하여 수행 할 수있는 작업에 제한을 두지 않습니다. 기본적으로 수동으로 작성할 수있는 모든 코드, 템플릿을 작성할 수 있습니다.
가장 확실한 예는 다음을 추가하는 것입니다.

C # 및 Java에서 제네릭 시스템은 클래스에 사용할 수있는 메소드를 알아야하며이를 가상 머신으로 전달해야합니다. 이를 알 수있는 유일한 방법은 실제 클래스를 하드 코딩하거나 인터페이스를 사용하는 것입니다. 예를 들면 다음과 같습니다.

string addNames<T>( T first, T second ) { return first.Name() + second.Name(); }

해당 코드는 C # 또는 Java로 컴파일되지 않습니다. T 실제로 Name ()이라는 메서드를 제공 . C #에서 다음과 같이 말해야합니다.

interface IHasName{ string Name(); };
string addNames<T>( T first, T second ) where T : IHasName { .... }

그런 다음 addNames에 전달한 항목이 IHasName 인터페이스 등을 구현하는지 확인해야합니다. 자바 문법이 다릅니다 (<T extends IHasName> ) 동일한 문제가 발생합니다.

이 문제에 대한 ‘고전적인’사례는 이것을하는 함수를 작성하려고합니다.

string addNames<T>( T first, T second ) { return first + second; }

인터페이스를 선언 할 수있는 방법이 없기 때문에 실제로이 코드를 작성할 수 없습니다 +메소드를 . 당신은 실패합니다.

C ++에는 이러한 문제가 없습니다. 컴파일러는 유형을 VM으로 전달하는 것을 신경 쓰지 않습니다. 두 객체 모두에 .Name () 함수가 있으면 컴파일됩니다. 그렇지 않으면 그렇지 않습니다. 단순한.

그래서, 당신은 그것을 가지고 있습니다 🙂

답변

template <unsigned int N>
struct product {
    static unsigned int const VALUE = N * product<N - 1>::VALUE;
};

template <>
struct product<1> {
    static unsigned int const VALUE = 1;
};

// Usage:
unsigned int const p5 = product<5>::VALUE;

template <typename T>
class Store { … }; // (1)

template <typename T>
class Store<T*> { … }; // (2)

Store<int> x; // Uses (1)
Store<int*> y; // Uses (2)
Store<string**> z; // Uses (2), with T = string*.

template <typename T>
struct X {
    void foo() { }
};

template <>
struct X<int> { };

typedef int my_int_type;

X<my_int_type> a;
a.|

template <typename T>
struct Y {
    typedef T my_type;
};

X<Y<int>::my_type> b;

X<typename Y<int>::my_type> b;

Y<int>::my_type(123);

//  java.lang.Enum Definition in Java
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {

//  Parsing String to Enum in Java
Colour colour = Colour.valueOf("RED");

//  Parsing String to Enum in C#
Colour colour = (Colour)Enum.Parse(typeof(Colour), "RED");

public <T> void Foo(Collection<T> thing)

public void Foo(Collection<?> thing)