template programming:how to prevent someone passing classes to my function template

hi,


let say i have a following scenario:

a function like tis

Code:

---



template <typename T1>
print (T1 x){
  cout << x << "\n";
}

---

how do i prevent user passing a class or a structure or aanoter function to my function print. I mean i know if a wrong thing is passed that i'll get an error eveuntaly but is there a way to explicitly check what has been passed. How is this done usually ?

thnx

baxy

Why not let it to the implementer of the other class to provide the stream I/O operators?

I cannot say that I have ever used it myself, but check out the Boost Concept Check library. Apparently it was slated for inclusion into C++11, but was eventually abandoned or postponed.

Quote:

---

Originally Posted by GReaper

Why not let it to the implementer of the other class to provide the stream I/O operators?

---

They have to do that already, with this approach. Wrapping the operation in a function makes it possible to change the implementation later (possibly to one that doesn't use ostream formatted output). As far as OP's question, I challenge the original requirement -- why shouldn't we be able to pass any object we want to print(), as long as a stream insertion operator is implemented?

The error messages generated can be hard to read, but there are techniques for making them somewhat easier to understand. laserlight mentioned this in post #3

For education and for fun, you can do it this way (using C++11):

Code:

---

#include <type_traits>
#include <vector>

template<typename T>
auto foo(const T& printy) -> void
{
        static_assert(!std::is_class<T>::value, "Type of argument printy must not be a class.");
        bar(printy);
}

template<typename T>
auto bar(const T& printy) -> void
{
        std::cout << printy << std::endl;
}

int main()
{
        int x = 0;
        std::vector<int> v;
        foo(x); // Change to v and you get a compile error
        return 0;
}

---

The reason I split foo into foo and bar is to prevent further compile errors from the compiler. You can put them together if you want.
Of course, this prevents you from passing in an object that supports operator <<. So if you conditionally want to detect if it supports being printed to an ostream (such as cout) with the << operator, you can do this (hang on to your boots!):

Code:

---

#include <type_traits>
#include <vector>
#include <utility>

template<typename T>
struct SupportsLeftStreamOperator
{
        typedef char yes[1];
        typedef char no[2];

        template<typename U> static yes& check(decltype(std::cout << std::declval<U>())*);
        template<typename U> static no& check(...);

        static const bool value = (sizeof(check<T>(nullptr)) == sizeof(yes));
};

template<typename T>
auto foo(const T& printy) -> void
{
        static_assert(!std::is_class<T>::value || SupportsLeftStreamOperator<T>::value, "Type of argument must support operator <<.");
        bar(printy);
}

template<typename T>
auto bar(const T& printy) -> void
{
        std::cout << printy << std::endl;
}

class test {};

std::ostream& operator << (std::ostream& out, const test& right) { return out; }

int main()
{
        int x = 0;
        test t;
        std::vector<int> v;
        foo(x);
        foo(t);
        //foo(v); // This will cause a compile error
        return 0;
}

---

So how the heck does this work, you wonder? What kind of insane magic is this? Well, first of, read up on SFINAE. That's what this builds upon.
The idea is that SupportsLeftStreamOperator calls check which is a template function. It will take one argument - a pointer to the type of the expression you get when sending the object to std::cout (ie std::cout << myobj). If this isn't possible, ie the type does not an appropriate overload, the compiler will skip the function and take the next function which is a catch-all. The "..." argument list makes it possible to catch all types of types without fuss and ambiguity. Then I simply compare the size of the type the function call would have yielded, had it been called. sizeof does not actually call functions, so I'm okay here. I'm returning a reference to an array because that's allowed according to the standard, while returning a simple array is not. Check the documentation for std::declval, too.
This is tricky stuff and can take some time getting used to. Don't use it in production code. At least not until you can reproduce it and understand the implications and compiler limitations.
But if you just want to play around? Sure - go right ahead!

Quote:

---

Originally Posted by baxy

How is this done usually?

---

It isn't. In the real world we don't arbitrarily stop people from doing things that would be perfectly fine, for no reason.

Quote:

---

Originally Posted by baxy

how do i prevent user passing a class or a structure or aanoter function to my function print.

---

You want to prevent a user passing a class, struct, or a function? What is the user permitted to pass? If you're that restrictive in what you want to pass, why is the function a template in the first place?

Usually, if the number of types permitted is small, the solution is to not do it as a template, but to overload the function for the specified types.

In C++11 there is the <type_traits> header, which can be used to check (at compile time) particular attributes of types.