В чем разница между Java Generics и C++ Generics?

В чем разница между Java Generics и C++ Generics?

Это два принципиально разных подхода к шаблонам (параметризованным типам). Java использует type erasure, C++ использует template instantiation. Это различие влияет на performance, типобезопасность и размер скомпилированного кода.

Java Generics: Type Erasure

Принцип: информация о типах стирается во время компиляции

// Что ты пишешь
List<String> strings = new ArrayList<>();
strings.add("hello");
String s = strings.get(0);

List<Integer> ints = new ArrayList<>();
ints.add(42);
Integer i = ints.get(0);

// Что видит JVM (type erasure)
List strings = new ArrayList();
strings.add("hello");
String s = (String) strings.get(0);  // явное приведение!

List ints = new ArrayList();
ints.add(42);
Integer i = (Integer) ints.get(0);   // явное приведение!

Как работает:

public class Container<T> {
    private T value;
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

// После компиляции (байт-код)
public class Container {
    private Object value;  // T становится Object!
    
    public Object getValue() {
        return value;
    }
    
    public void setValue(Object value) {
        this.value = value;
    }
}

// При использовании
Container<String> container = new Container<>();
container.setValue("hello");
String result = (String) container.getValue();  // явное приведение при чтении

Следствия type erasure:

// Нельзя использовать T в instanceof
if (value instanceof T) {  // compile error!
}

// Нельзя создать T[]
T[] array = new T[10];  // compile error!
// правильно:
T[] array = (T[]) new Object[10];

// Нельзя использовать T в static контексте
public static <T> T getDefault() {
    return new T();  // compile error!
}

// Нельзя overload с разными T
public void process(List<String> strings) { }
public void process(List<Integer> ints) { }  // compile error!
// эти методы идентичны после erasure

C++ Templates: Code Generation

Принцип: компилятор генерирует отдельный код для каждого типа

// Шаблон
template <typename T>
class Container {
private:
    T value;
public:
    T getValue() const {
        return value;
    }
    
    void setValue(T val) {
        value = val;
    }
};

// Использование
Container<std::string> stringContainer;
stringContainer.setValue("hello");
std::string s = stringContainer.getValue();  // без приведения!

Container<int> intContainer;
intContainer.setValue(42);
int i = intContainer.getValue();  // без приведения!

// Компилятор генерирует ДВА разных класса:

// Container<std::string>
class Container_String {
private:
    std::string value;  // реальный string!
public:
    std::string getValue() const { return value; }
    void setValue(std::string val) { value = val; }
};

// Container<int>
class Container_Int {
private:
    int value;  // реальный int!
public:
    int getValue() const { return value; }
    void setValue(int val) { value = val; }
};

Сравнение

Детали Type Erasure

Проблема 1: потеря информации о типе

public class GenericTest {
    public static void main(String[] args) throws Exception {
        List<String> strings = new ArrayList<>();
        List<Integer> ints = new ArrayList<>();
        
        // Они имеют РАЗНЫЕ типы?
        System.out.println(strings.getClass() == ints.getClass());  // true!
        // После erasure они одного класса!
        
        // Нельзя узнать тип элементов в runtime
        List<?> unknown = strings;
        // unknown.add(42);  // compile error
        // но это runtime check, не type check
    }
}

Проблема 2: wildcards

// Java пришлось добавить wildcards из-за type erasure
public void process(List<? extends Number> numbers) {
    // ? extends Number — это не тип, это PLACEHOLDER
    // C++ просто сгенерировал бы код для каждого наследника Number
}

// Bounded type parameters
public <T extends Comparable<T>> void sort(List<T> list) {
    // T должен реализовать Comparable
    // Это компенсация за потерю информации
}

Проблема 3: массивы

// Java не может создать массив параметризованного типа
List<String>[] array = new List<String>[10];  // compile error!

// Причина: runtime представление одинаково
List[] array = new List[10];  // работает
array[0] = new ArrayList<Integer>();  // ошибка не поймается!

// C++ это позволяет
std::vector<std::string>* array = new std::vector<std::string>[10];
// Каждый элемент имеет реальный тип

Детали C++ Templates

Преимущество 1: полная типобезопасность

template <typename T>
class Container {
public:
    T get() { return value; }  // T имеет реальный тип!
};

Container<int> ic;
int i = ic.get();  // без приведения, компилятор знает тип

// Java эквивалент
public class Container<T> {
    public T get() { return (T) value; }  // приведение!
}

Container<Integer> ic = new Container<>();
Integer i = ic.get();  // требует приведения в bytecode

Преимущество 2: специализация

// Общий шаблон
template <typename T>
class Vector {
    void optimize() {
        // общая оптимизация
    }
};

// Специализация для bool (экономия памяти)
template <>
class Vector<bool> {
    // bit-packed представление
    void optimize() {
        // специальная оптимизация для bool
    }
};

// Java не может сделать это
public class ArrayList<T> {
    // одна реализация для всех типов
}

Проблема C++: code bloat

// Для каждого типа компилятор генерирует новый класс
Vector<int> v1;
Vector<double> v2;
Vector<std::string> v3;
Vector<MyClass> v4;
Vector<AnotherClass> v5;
// Это 5 разных классов в бинарнике!
// Размер может вырасти в 10+ раз

Практические примеры

Java: множественное наследование и type erasure

public class MultiMap<K, V> extends HashMap<K, V> {
    public void putAll(Map<K, V> map) {
        // все List<K,V> имеют одинаковое runtime представление
    }
}

// Нельзя перегрузить по типам K и V
public void add(List<String> strings) { }
public void add(List<Integer> ints) { }  // compile error!
// После erasure оба метода идентичны

C++: перегрузка по типам

template <typename T>
void add(std::vector<T>& vec, T val) { }

// Специализация для строк
template <>
void add<std::string>(std::vector<std::string>& vec, std::string val) {
    // специальная реализация
}

// Специализация для int
template <>
void add<int>(std::vector<int>& vec, int val) {
    // другая реализация
}

// Все три функции существуют в бинарнике!

Почему Java выбрала Type Erasure

1. Обратная совместимость

// Старый код без generics
List list = new ArrayList();
list.add("hello");

// Новый код с generics
List<String> strings = new ArrayList<>();
strings.add("hello");

// Должны работать вместе!
List<String> s = list;  // нельзя запретить

2. Размер JVM

Java: один список с erasure
C++: ArrayList для int, ArrayList для String, ArrayList для Double...

Java bytecode:        50KB
C++ compiled binary: 500KB+

3. Скорость компиляции

Java: быстро (type erasure)
C++: медленно (генерирует код для каждого типа)

Workarounds в Java

Сохранение информации о типе (Class<T>)

public class Container<T> {
    private Class<T> type;
    private T value;
    
    public Container(Class<T> type) {
        this.type = type;
    }
    
    public T createNew() {
        try {
            return type.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

// Использование
Container<String> container = new Container<>(String.class);
String s = container.createNew();

TypeToken для сохранения типов

// Gson library использует это
public class TypeToken<T> {
    final Type type;
    
    protected TypeToken() {
        // используем рефлексию на суперклассе
        this.type = getSuperclassTypeParameter(getClass());
    }
}

// Использование
TypeToken<List<String>> typeToken = new TypeToken<List<String>>() { };
Type type = typeToken.getType();
List<String> list = gson.fromJson(json, type);

Итоговое сравнение производительности

Java List<String>:
- Compilation: быстро (erasure)
- Runtime: требует (String) cast
- Memory: один класс

C++ std::vector<std::string>:
- Compilation: медленно (код генерируется)
- Runtime: без cast, быстрее
- Memory: больше code size

Вывод

Java Generics (Type Erasure):

• ✅ Обратная совместимость
• ✅ Малый размер бинарника
• ✅ Быстрая компиляция
• ❌ Потеря информации о типе
• ❌ Требует приведения в bytecode
• ❌ Нельзя использовать instanceof/new с T

C++ Templates (Code Generation):

• ✅ Полная типобезопасность
• ✅ Специализация кода
• ✅ Быстрее в runtime (без cast)
• ❌ Code bloat (большой бинарник)
• ❌ Медленная компиляция
• ❌ Экспоненциальный рост кода

Это фундаментальное архитектурное решение, отражающее разные философии: Java выбрала совместимость, C++ выбрал производительность.