Allow member function for a specific type only

Question

I am using C++ and templates - but I need to allow using a member function for a specific type and prevent other types from using this function.

For example: I want this class to have print() for all types but have foo() for just type int. How can I do that ?

#include<iostream>

template <class type>
class example
{
private:
    type data;

public:
    void print(); // for all types

    void foo();   // only for 'type' == int?
};

Don't use templates? Seems like templates are the wrong tool if you just want to allow methods to apply to specific types. Post sample code to get better answers. — Andrew Henle, Apr 22 '15 at 14:11
Post some minimal code. As I see it, you have two possibilities: Use various interfaces, or use function overloading based on parameter type. — Werner Erasmus, Apr 22 '15 at 14:15
Take a look at `std::enable_if`, it probably does what you want. — Xaqq, Apr 22 '15 at 14:18

Potatoswatter · Answer 1 · 2015-04-23T03:30:01.027

4

Factor the common, generic functionality into a base class. Specializations can inherit that.

namespace detail {

template <class type>
class example_base
{
private:
type data ;

public:
void print();
};

} // end namespace detail

template <class type>
struct example
    : detail::example_base<type> {
    using detail::example_base<type>::example_base; // inherit any constructors
};

template <> // specialize the class
struct example< int >
    : detail::example_base<int> {
    using detail::example_base<int>::example_base; // inherit any constructors

    void other_function(); // extend the basic functionality
};

edited Apr 23 '15 at 03:30

answered Apr 22 '15 at 14:21

Potatoswatter

134,909
25
265
421

but I need the same class name – Youssef Emad Apr 22 '15 at 14:37
Youssef, specializations need not inherit from it. You could still have the same name if you use full specialization. – Werner Erasmus Apr 22 '15 at 15:07
@Potatoswatter, As the Op requires the same name, I propose modifying the solution to use full specialisation: – Werner Erasmus Apr 22 '15 at 15:08
@YoussefEmad I'm not sure what you mean by that. The interface here is still called `example`. The class `example_base` is not presented to the user. I've edited the answer to put it in a namespace, to clarify. – Potatoswatter Apr 23 '15 at 03:31

Banan · Answer 2 · 2015-04-23T08:14:47.167

You could use std::enable_if and do something like this to obtain exactly what you want:

#include <iostream>
#include <type_traits>

template<class T>
class example
{
   private:
      T data;
   public:
      void print() 
      { 
         std::cout << " hello " << std::endl;
      }

      template<class U = T // make the function templated on U, but with default type T
             , typename std::enable_if<std::is_integral<U>::value>::type* = nullptr // enable only for when U (T) is an integral type
             >
      void foo()
      {
         std::cout << " I will only compile when T is an integral type " << std::endl;
      }
};


int main()
{
   example<int> integer_example;
   integer_example.print();
   integer_example.foo(); // <--- compiles fine as int is integral

   example<double> double_example;
   double_example.print();
   //double_example.foo(); // <--- will not compile

   return 0;
}

In the std::enable_if you can also put std::is_same<U,int>::value instead of std::is_integral<U>::value to only allow the function only to be used for int and not other integral types.

score 2 · Answer 3 · answered Apr 22 '15 at 14:21

2

You can specify the template for some types. See this example :

template <typename T>
class MyClass
{
  private:
    double my_function() { return 1.0; }
};

template <>
class MyClass<double>
{
  public:
    double my_function() { return 2.0; }
};

int main()
{
  MyClass<double> a;
  MyClass<int> b;
  double x = a.my_function();  // this works
  // double y = b.my_function(); // not allowed
  return 0;
}

Tested with GCC 4.7.2.

answered Apr 22 '15 at 14:21

Caduchon

4,574
4
26
67

How does this handle the common function case? – Barry Apr 22 '15 at 14:31
Actually, it doesn't. But it can be used as a sub class providing the functionnality. – Caduchon Apr 22 '15 at 14:37
This means that If I have 10 common functions and a unique one I will have to rewrite the 10 functions again – Youssef Emad Apr 22 '15 at 14:40
1

You can inherit from a class providing the common 10 functions. – Caduchon Apr 22 '15 at 14:46
@Caduchon That is my answer :) . – Potatoswatter Apr 23 '15 at 03:32

Allow member function for a specific type only

3 Answers3