uncommon function of classes used in one template function in C++ - c++

Question

I will pass "stack" and "queue" as template type in following codes.
Knowing that .front() and .top() is not the common function between "queue" and "stack", I use "if" to check.
But it still couldn't compile. (error C2039: 'top' is not the member of std::queue<_Ty>)
Is there any way to solve this problem?
template<typename T>
void push_pop(string *str, T *containers){
string s = typeid(containers).name();
if(s[11]=='q'){
str->push_back(containers->front()); containers->pop();
}else{
str->push_back(containers->top()); containers->pop();
}
}
I know I could use function overloading but I want to solve this using template.
Thanks for the answer!

Answer 1

The problem is that the compiler has to compile both branches of the check, and it cannot compile container.top() for a queue nor container.front() for a stack.
You have to implement separate function templates for std::queue and std::stack:
template<typename V, typename C>
void push_pop(std::string &str, std::stack<V, C> &container) {
str.push_back(container.top());
container.pop();
}
template<typename V, typename C>
void push_pop(std::string &str, std::queue<V, C> &container) {
str.push_back(container.front());
container.pop();
}
It is possible (and I would recommend it) to do this for only the relevant parts:
template<typename V, typename C>
V const &first_element(std::stack<V, C> const &container) {
return container.top();
}
template<typename V, typename C>
V const &first_element(std::queue<V, C> const &container) {
return container.front();
}
template<typename T>
void push_pop(std::string &str, T &container) {
str.push_back(first_element(container));
container.pop();
}

Answer 2

(untested) - I use a macro like the following:
#define FUNC_TEST(func) \
template<typename T> \
struct has_##func \
{ \
template <typename _1> static std::true_type test(decltype(&_1::func)*); \
template <typename > static std::false_type test(...); \
static const bool value = decltype(test<T>(0))::value; \
}
Then, for all the functions I need to test for, I would use the macro to generate the test code, for example:
FUNC_TEST(top);
FUNC_TEST(front);
Then, I would define several helper functions to handle the actual push back:
// If the type supports top(), then the first variant is enabled and selected
template <typename F>
inline enable_fn<has_top<F>, void> use_top(F* o, std::string* dest)
{ dest->push_back(o->top()); }
template <typename F>
inline disable_fn<has_top<F>, void> use_top(F*, std::string*)
{ }
// If the type supports front(), the first variant is selected from below automatically
template <typename F>
inline enable_fn<has_front<F>> use_front(F* o, std::string* dest)
{ dest->push_back(o->front()); }
template <typename F>
inline disable_fn<has_front<F>> use_front(F*, std::string*)
{ }
When calling, simply call both variants, and the compiler will select the appropriate action based on the SFINAE test.
template<typename T>
void push_pop(string *str, T *container){
use_top(container, str);
use_front(container, str);
container->pop();
}
It looks like we're calling both top() and front(), but depending on whether the container supports top() or front() one or the other function call will be compiled out. If the type T supports both front() and top(), it's a little problematic, but I'll leave that as an exercise for you to fix...
(NOTE: you'll need enable_fn which looks something like:
template <typename T>
using type_of = typename T::type;
template <typename C, typename R = void>
using enable_fn = type_of<std::enable_if<C::value, R>>;
I'll leave disable_fn as an exercise for you...

Answer 3

Problem of your code is that you are trying to make run-time check which results in requirement to container class provide both top() and front().
One approach to solve this is, as #Wintermute suggests, to use template specialization.
If you want more fancy and generic way, you can use SFINAE approach, which in combination with C++11 gives clean and nice looking code. Assuming we have only two possible kinds of containers - with either front() or top() method provided (adding new kinds of functions is pretty easy):
template<typename container>
auto get_from_container(container* c, int) -> decltype(std::declval<container>().front(), typename container::value_type()) {
return c->front();
}
template<typename container>
typename container::value_type get_from_container(container* c, long) {
return c->top();
}
template<typename T>
void push_pop(string *str, T *containers){
str->push_back(get_from_container(containers, 0)); containers->pop();
}
Notice second type argument in get_from_container - it is required to shadow "default" implementation with top() method (as described here)