What makes a template different from a generic?

Question

I understand the aspects of templates in C++ that are different from generics in Java and C#. C# is a reification, Java uses type erasure, C++ uses duck typing, etc. There are a number of things C++ templates can do that Java and C# generics can't (e.g. template specialization). But there are a number of things Java generics can do that C# and C++ can't (e.g. make a bounded type parameter of a family of generics like class Foo<T extends Comparable<?>>), and a number of things C# generics can do that Java and C++ can't (e.g. runtime generic reflection). [EDIT: Apparently Java generics are much weaker than I thought. (Which is saying something.) In any case, despite their ineptness, they are still considered generics along with C#'s generics.]

What I don't understand is what conceptually makes templates different from generics. What parts of C++ templates are things that cannot be done in something that isn't a template, but is a generic? For example, if I were to implement a language that supported templates, what would absolutely need to be in it? What could I leave out that would be necessary for the language to support generics?

My guess is that templates are a super-set of generics or they are a way to implement generics, but I don't really understand what separates a true template from a true generic.

Answer 1

Hm.. if you say you understand C++ templates in depth and say that you don't see/feel the difference between generics and them, well, that most probably you are right :)

There are many differences that will describe how/why generics are better than templates, list tons of differences, etc, but that's mostly irrelevant to the core of the idea.

The idea is to allow better code reuse. Templates/generics provide you a way to build a some kind of higher-order class definitions that abstract over some of the actual types.

In this terms, there is no difference between them, and the only differences are those enforced by specific features and constraints of the underlying language and runtime.

One may argue that generics provide some extra features (usually when talking about dynamic introspection of object's class tree), but very few of them (if any at all) cannot be implemented manually in C++'s templates. With some effort, most of them can be implemented, or emulated, hence they are not good as a distinction between 'proper generics' and 'real templates'.

Others will argue that the sheer potential power of optimization that is available thanks to the C++'s copy-paste behavior is the difference. Sorry, not true. JITs in Java and C# can do it too, well, almost, but do it very well.

There is however one thing that really could make the Java/C#'s generics a true subset of C++'s templates features. And you even have mentioned it!

It is template specialization.

In C++, each specialization behaves as a completely different definition.

In C++, template<typename T> Foo specialized to T==int may look like:

class Foo<int> 
{
    void hug_me();

    int hugs_count() const;
}

while "the same" template specialized to T==MyNumericType may look like

class Foo<MyNumericType> 
{
    void hug_me();

    MyNumericType get_value() const;
    void  reset_value() const;
}

FYI: that's just pseudocode, won't compile:)

Neither Java's nor C#'s generics can do that, because their definition states that all generic-type-materializations will have the same "user interface".

More to it, C++ uses a SFINAE rule. Many "theoretically colliding" specializations' definitions may exist for a template. However, when the template is being used, only those "actually good" are used.

With classes similar to the example above, if you use:

 Foo<double> foood;
 foood.reset_value();

only the second specialization would be used, as the first one would not compile because of ... "reset_value" missing.

With generics, you cannot do that. You'd need to create a generic class that has all possible methods, and then that would at runtime dynamically inspect the inner objects and throw some 'not implemented' or 'not supported' exceptions for unavailable methods. That's... just awful. Such things should be possible at compile-time.

The actual power, implications, problems and overall complexity of template specialization and SFINAE is what truly differentiates the generics and templates. Simply, generics are defined in a such way, that specialization is not possible, hence SFINAE is not possible, hence, the whole mechanism is paradoxically much easier/simplier.

Both easier/simplier to implement in the compiler's internals, and to be understood by non-savant brains.

Although I agree with the overall benefits of generics in Java/C#, I really miss the specializations, interface flexibility, and SFINAE rule. However, I would not be fair if I'd not mention one important thing related to sane OO design: if you template-specialization for type xxx actually changes it's client API, then most probably it should be named differently and should form a different template. All the extra goodies that templates can do were mostly added to the tools set because ... in C++ there was no reflection and it had to be emulated somehow. SFINAE is a form of compile-time reflection.

Hence, the biggest player in the world of differences gets reduced to a curious (beneficial) sideeffect of a hotfix applied to mask the runtime's deficiency, which is the almost complete lack of runtime introspection :))

Therefore, I say that there are no difference other than some arbitrary ones enforced by laguage, or some arbitrary ones enforced by the runtime platform.

All of them are just a form of higher-order classes or functions/methods, and I think that this is the most important thing and feature.

Answer 2

First, I find it interesting that RTTI/introspection is a big part of most of the answers. Well, that is not a difference of generics vs. templates, but rather languages with instrospection vs. languages that don't have it. Otherwise you can also claim that to be a difference of C++ classes with Java classes, and C++ functions with Java functions...

If you take instrospection out of the way, the main difference is that templates define a turing complete language, functional in style although with a horrible grammar at it on which you can program. The first really complex example I heard of (I would love having the code, but I don't) was a program that calculated prime numbers at compile time. Which does bring another difference: templates can take type arguments, or template arguments or non-type arguments (non-type refers to anything that is not a type or a template, like an int value).

This has been mentioned in other answers, but just saying that templates can be specialized and that there is SFINAE does not clearly state that those two features are sufficient to generate a turing complete language.

Answer 3

there are a number of things Java generics can do that C# and C++ can't (e.g. make a bounded type parameter of a family of generics like class Foo<T extends Comparable<?>>)

Not entirely true for that example:

template <typename Comparable>
struct Foo {
    static bool compare(const Comparable &lhs, const Comparable &rhs) {
        return lhs == rhs;
    }
};

This class template will successfully instantiate the compare function only if the template parameter is an equality-comparable type. It's not called a "bounded type parameter", but it serves the same purpose.

If in C++ you want to treat Comparable as an explicit interface (i.e. a base class) rather than a duck-typed concept, then you can static_assert(is_base_of<Comparable, T>::value, "objects not Comparable");, or whatever.

Answer 4

no, templates are not a super-set of generics, with C++ templates you have no runtime support at the same level as you have with C# generics, meaning that RTTI in C++ is unable to detect and provide you metadata of templates like Reflection does for generics in C#.

beside this, I like this snippet:

C++ templates use a compile-time model. When a template is used in a C++ program, the effect is as if a sophisticated macro processor had been used.

C# generics are not just a feature of the compiler, but also a feature of the runtime. A generic type such as List maintains its generic-ness (genericity) after it has been compiled. Or, to look at it another way, the substitution that the C++ compiler does at compile time is done at JIT time in the C# generic world.

see here for the full article: How do C# generics compare to C++ templates?

Answer 5

This is an old thread, and my rep is too low to comment on accepted answer, but I wanted to add:

In addition to explicit specialization, another key difference in C++ templates and C# generics are non-type template parameters used in C++:

template<int bar> class Foo {};

Foo<1> a;
Foo<2> b;

a = b; //error, different types. 

Non-type template parameters can be of any integer types, enumerations, as well as pointers that can be determined at compile time (static storage variables and function pointers). In C++20, they can be of class type too with certain restrictions.

Neither C# nor Java generics can do that.

You can explicitly specialize on non-type parameters as well.

As a side-note, the D programming language uses the term 'template' as nomenclature for generic programming, and its features feel more aligned in spirit to C++ than C#/Java to me at least.

I'm not aware of technical reasons why non-type parameters were left out of C#, but as the language I use more-so than others these days, I miss the feature once in a while.

Answer 6

I'll confine my answers to C++ templates vs. Java generics.

1. C++ templates (class templates and functions templates) are mechanisms for implementing compile-time polymorphism, but AFAIK Java generics are run-time mechanisms.
2. using C++ templates, you can do generic programming and it's actually is totally separate programming style/paradigm, but Java generics are OO style per se. see below:

3. C++ templates are based on Duck typing, but Java generics are based on Type Erasure. In C++, vector<int>, vector<Shape *>, vector<double> and vector<vector<Matrix>> are 4 distinct types, but in Java Cell<int>, Cell<Integer> Cell<double> and Cell<Matrix> are same type. More precisely, during code generation compiler erases the type at first place. You can check it by following code from the following paper: Vladimir Batov. Java Generics and C++ Templates. C/C++ Users Journal, July 2004.

   public class Cell<E>
   {
      private E elem;
      public Cell(E elem)
      { 
         this.elem = elem;
      }
      public E GetElement()
      { 
         return elem;
      }
      public void SetElement(E elem)
      { 
         this.elem = elem;
      } 
   }
   
   boolean test()
   { 
     Cell<Integer> IntCell(10); 
     Cell<String> StrCell(“Hello”);
     return IntCell.getClass() ==
            StrCell.getClass(); // returns true
   }
   

In short, Java pretends to be generic, while C++ actually is.