Is there equivalent of <? extends T>, <? super T> in C++?

1. Is there equivalent of <? exten开发者_开发技巧ds T>, <? super T> in C++?

2. Also, does <? extends T>, <? super T> work even if T is an interface in Java?

It doesn't have quite nice syntactic sugar as in Java but it's manageable well with boost/type_traits . See http://www.boost.org/doc/libs/1_40_0/libs/type_traits/doc/html/index.html for more info.

#include <boost/type_traits.hpp>
#include <boost/static_assert.hpp>

class Base {};
class Derived_from_Base : public Base {};
class Not_derived_from_Base {};

template<typename BASE, typename DERIVED>
void workOnBase()
{
    BOOST_STATIC_ASSERT((boost::is_base_of<BASE, DERIVED>::value)); 
}

int main()
{
    workOnBase<Base, Derived_from_Base>();     // OK
    workOnBase<Base, Not_derived_from_Base>(); // FAIL
    return 0;
}

1>d:...\main.cpp(11) : error C2027: use of undefined type 'boost::STATIC_ASSERTION_FAILURE' 1> with 1> [ 1> x=false 1> ]

To answer your second question: yes. As far as generics is concerned, interfaces are treated the same as real classes.

I'll leave the first question to the more C++-savvy people.

You can restrict the range of a template parameter in C++ using the various traits mechanisms, of which there are implementations available in boost.

Usually you don't - the reason the syntax exists in Java and C# is that they use generics, not templates.

Java generics generate shared code which uses virtual dispatch from the base type, rather than generating code for each type used as a template argument. So usually you are using the restriction in order to allow you to call methods on objects of the type used as the template parameter.

As C++ generates code for each type used as a template parameter, it doesn't need to know about a base type for them.

For example, a template class for a matrix will use +,-,* operators on its target type. In can then be used for any type which supports those operators. If it was arbitrarily restricted to doubles and ints, then you couldn't use the template with a complex<double> or run a test with a type which supports interval arithmetic, even though those types provide those operators, and the matrix library would be valid using them.

The ability to work on arbitrary types which have the same shape is the power of templates, and makes them more useful. It's up to the client code to decide whether or not it's valid to use that template with that type (as long as it compiles), and the customer is always right. The inability to work on arbitrary types which have the same shape, and the requirement to specify restrictions to call methods other than those of java.lang.Object is a weakness of generics.

This worked for me:

#include <iostream>

class MyBase {}; 
class A : public MyBase {};    
class B {};

template <class T>
typename std::enable_if<!std::is_base_of<MyBase, T>::value>::type
Foo(T &v) {
    std::cout << "Foo 1" << std::endl;
}

template <class T>
typename std::enable_if<std::is_base_of<MyBase, T>::value>::type
Foo(T &v) {
    std::cout << "Foo 2" << std::endl;
}

int main() {
  A a;
  B b;
  Foo(a);
  Foo(b);
  return 0;
}

This is an extension that sadly was removed from the draft standard of C++0x as it "was not ready". However, it is possible to simulate this using static asserts (that is a part of C++0x and Boost as people have mentioned here).