Templates (not quite partial specialization but perhaps similar)

[cl41re]

Hi,

For a templated class, I would like to be able to require that the template typename extends a certain class. The reason for this is to ensure that the correct methods are implemented.

I have written a mock example, in this case the class "tester" expects its template typename to have the method "test" associated with it (this is achieved by inheritance of supertype). How could I prevent a future developer/user trying to pass a class template which does not extend the supertype class?

class supertype{
public:
  virtual int test()=0;
   
};

class subType1 : public supertype{
public:
  virtual int test(){return 1;};
};

class subType2 : public supertype{
public:
  virtual int test(){return 2;};
};

template < class T >
class tester{
  public :
    int run(){
       T obj;
       return obj.test();
    }
};

tester<subType2> a1
a2.run();

tester<int> a2;
//I want this to not compile.
a2.run();

(This code is just to illustrate my question, so it might not compile.)

I hope it makes sense.

Thank you in advance,
Claire

[PanGalactic]

It will not compile. If the template type does not implement the function that the template class calls, the compilation will fail. Always.

[Bazzy]

What you are asking is called 'concepts', they are not part of the language but they are planned to be included in some future standard
http://en.wikipedia.org/wiki/Concepts_%28C%2B%2B%29

[moorecm]

It appears to me that you are attempting to solve too many problems at once.

What you have posted basically does exactly as you are expecting. After a few syntactical updates, it compiles and line 30 does not compile because int is not a user-defined type with a method signature 'int test()' accessible by tester. The compiler knows that int is not a suitable type for tester and it would also know if you created a class that did not have the same test method signature.

The problem (I'm assuming this is your concern) is that if you created an arbitrary class that coincidentally defines a public method with that signature, it would compile. Even though it is not a subclass of your superclass.

This question remains, though: why are you trying to use templates? You could overcome the limitations that I have mentioned by passing a reference or pointer to the constructor of the tester class. tester could store the reference/pointer as a private member and invoke the appropriate method on it inside of its run method. This does, however, mean that the user of the tester class now has the responsibility of instantiating the superclass object before creating the tester object. If you have additional concerns about their construction, that would be a separate problem that needs to be solved.

Here is my solution mentioned above:

class supertype
{
public:
    virtual int test() = 0;
};

class subType1 : public supertype
{
public:
    virtual int test() { return 1; }
};

class subType2 : public supertype
{
public:
    virtual int test() { return 2; }
};

class tester
{
    supertype & _super;
public:
    tester( supertype & super ) : _super( super ) {};
    int run() {
        return _super.test();
    }
};

class bob
{
public:
    int test() { return 3; }
};

//...

subType2 type2;
tester a1( type2 );    // no problem
a1.run();

bob typebob;
tester a2( typebob );  // compiler error:
                       // no matching function for call to `tester::tester(bob&)'
a2.run();

[blackcoder41]

are you a java programmer? your terminologies seems java to me.

try this

template < supertype T >
class tester{
  public :
    int run(){
       T obj;
       return obj.test();
    }
};

[jsmith]

How could I prevent a future developer/user trying to pass a class template which does not extend the supertype class?

You can also look at the boost::type_traits library (www.boost.org)

It provides the is_base_of type trait that allows you to determine, at compile time, whether or not a
class is a base class of another.

[blackcoder41]

or you can just document your code.

[cl41re]

Thank you very much for all your replies, its really helpful.

PanGalactic, yes it will compile but as moorecm says;

The problem (I'm assuming this is your concern) is that if you created an arbitrary class that coincidentally defines a public method with that signature, it would compile. Even though it is not a subclass of your superclass.

moorecm, you're right, I don't really need templates in this case, it just complicates it unnecessarily. Your solution is much neater and works. :)

blackcoder41, in case your interested in the result, when I tried

template < supertype T >
class tester{
  public :

I got the error;

error: 'class supertype' is not a valid type for a template constant parameter

Also I am predominantly a java programmer, I clearly need to learn the C++ lingo.

And thanks for the info on boost and concepts, they have made an interesting read and will bare them in mind next time.

[blackcoder41]

@cl41re
hehe, i expected that error. yeah why would you use template anyway. .
here a trivia, in c++ they call super class as base class, and derive class for sub class