is there a way to put restrictions on template classes?

c++ template class
c++ template function implementation in cpp file
c++11 extern template
class templates in c++ with simple example
c++ template function in class
c++ template class definition
c++ template class example stackoverflow
c++ convert class to template

I was just wondering if I can make a template class like so:

template <class T> void DoSomething(T something);

but I want to restrict it to only take a float or an int for example. Can this be done?

One option is to use boost::enable_if, which can be used to exclude your template function from being considered depending on the type that T represents. For example,

template <class T>
typename boost::enable_if<boost::is_arithmetic<T>, void>::type DoSomething(T t);

Would restrict your template function to integral and floating-point types.

template restrictions in C++, I am creating a template class in C++ for numeric operations and I want to restrict it to only numbers or similar numeric types. My question is that is there any way  consider a template function prototype like this: template <class X> void myfunc1(X &var); or template <class X> X* myfunc2(); etc. Is there a way to impose a restriction on what X can be? E.g. I might want myfunc1 to accept only double or int, or I might want myfunc2 to return only double* or int*. Can I do that in the prototype? many thanks in advance.

yes, Take a look at template specialization. here-

Templates, C++ FAQ, In the same way, a class template is a cookie cutter for a description of how to Instead, you add the template<typename T> before the class definition (the T can #include <limits>; template<typename T> inline std::string stringify(const T& x)​  Templates are a way of making your classes more abstract by letting you define the behavior of the class without actually knowing what datatype will be handled by the operations of the class. In essence, this is what is known as generic programming; this term is a useful way to think about templates

Also you can just overload the function for all supported types. This produces more code than using (boost|std)::enable_if.

How to restrict possible types for a tem - C++ Forum, If you decide templates aren't the right way, could you simply state if it's possible to restrict the set of type applicable to a template and a short hint  In a function template, there are no restrictions on the parameters that follow a default, and a parameter pack may be followed by more type parameters only if they have defaults or can be deduced from the function arguments. Default parameters are not allowed

In the six years since this was asked, things have improved somewhat! I’ll post a brief update.

std::enable_if can be used in a third place now, which gets rid of the issue with some functions simply not having a place in the signature to stick it. This is to use trailing dummy template arguments.

    template<typename R ,
        typename = std::enable_if_t<is_range_t<R>::value>  >
    Fizzer_t (const R& range_of_itemdefs);

➽ The introduction of alias templates means you don’t need template::type everywhere! That alone is a big improvement. They also make it easier to bundle up constraints to reuse them or simply detail them elsewhere than the constrained function’s signature.

Expression SFINAE, and declspec, means you can easily just show the kind of code syntax you want to work and reject the function if that’s not so.

➽ Training return types work in conjunction with this, so you can use the arguments of the function together and have a place to put the SFINAE expression to sniff out its validity.

➽ The above, plus some stuff that’s been figured out already and packaged up in library/idiom form gives us more idiomatic (this readable) constraining, including the detection idiom.

constexpr has been called a game-changer for template metaprogramming in general. You don’t need to use metafunctions to do simple arithmetic.

➽ The if constexper construct can eliminate the need for writing such constraints as part of overloading!

➽ If you want to be on the bleeding edge, Concepts Lite are nearly ready and are experimental in some compilers now. Other solutions exist to emulate most of it in a systematic manner.

C++ Programming: From Problem Analysis to Program Design, The function members of a class template are considered function templates. the definition of the member insert of the class listType is: template <class to remove additional content at any time if subsequent rights restrictions require it. Because templates are compiled when required, this forces a restriction for multi-file projects: the implementation (definition) of a template class or function must be in the same file as its declaration. That means that we cannot separate the interface in a separate header file,

Classes (II) - C++ Tutorials, And types in C++ not only interact with code by means of constructions and assignments. The access to its data members from outside the class is restricted to The constructor is the only member function in the previous class template and  There is no limit on the number of classes of shares that can be set out in the articles. If there is more than one class, the rights, privileges, restrictions and conditions for each class must also be indicated in the articles. If there is only one class of shares, those shares must, as a minimum, have: the right to vote

Group Policy: Fundamentals, Security, and the Managed Desktop, To do something like this, you might set the GPO at a high level (maybe a section, we talked about the Group Policy Preference Extensions and how, in using that Templates a System a Device Installation a Device Installation Restriction (seen In the first set, there are two policy settings named Custom Classes: Deny  The Java Tutorials have been written for JDK 8. Examples and practices described in this page don't take advantage of improvements introduced in later releases and might use technology no longer available.

std::enable_if, This metafunction is a convenient way to leverage SFINAE to conditionally remove functions from overload resolution based on type traits and  Non-generic, in other words, concrete, classes can inherit from closed constructed base classes, but not from open constructed classes or from type parameters because there is no way at run time for client code to supply the type argument required to instantiate the base class.