используя std :: is_same, почему моя функция все еще не может работать для 2 типов

Question

Я пытаюсь написать функцию, которая может печатать как стек, так и очередь, мой код выглядит следующим образом

template<typename Cont>
void print_container(Cont& cont){
    while(!cont.empty()){
        if(std::is_same<Cont, stack<int>>::value){
            auto elem = cont.top();
            std::cout << elem << '\n';
        } else {
            auto elem = cont.front();
            std::cout << elem << '\n';
        }
        cont.pop();
        std::cout << elem << '\n';
    }
}

int main(int argc, char *argv[])
{
    stack<int> stk;
    stk.push(1);
    stk.push(2);
    stk.push(3);
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);

    std::cout << "print stack" << endl;
    print_container(stk);
    std::cout << "print queue" << endl;
    print_container(q);

    return 0;
}

Но здесь это не работает , информация об ошибке:

demo_typeof.cpp:35:30: error: no member named 'front' in 'std::__1::stack<int, std::__1::deque<int, std::__1::allocator<int> > >'
            auto elem = cont.front();
                        ~~~~ ^
demo_typeof.cpp:52:5: note: in instantiation of function template specialization 'print_container<std::__1::stack<int, std::__1::deque<int, std::__1::allocator<int> > > >' requested here
    print_container(stk);
    ^
demo_typeof.cpp:32:30: error: no member named 'top' in 'std::__1::queue<int, std::__1::deque<int, std::__1::allocator<int> > >'
            auto elem = cont.top();
                        ~~~~ ^
demo_typeof.cpp:54:5: note: in instantiation of function template specialization 'print_container<std::__1::queue<int, std::__1::deque<int, std::__1::allocator<int> > > >' requested here
    print_container(q);
    ^
2 errors generated.

Я знаю, что это проблематично, и знаю, что C ++ статически типизирован и не имеет слишком много поддержки времени выполнения. но мне интересно конкретная причина, почему это не работает, и как с этим бороться.

P.S .: Фактическое значение оценки типа контейнера заключается в следующем: Вы можете просто изменить функцию DFS на BFS, передавая контейнер очереди вместо стека. Таким образом, BFS и DFS могут совместно использовать большую часть кода.

P.P.S: Я нахожусь в среде C ++ 11, но также приветствуются ответы на более ранние или более поздние стандарты.

Answer 1

Если вы можете использовать C ++ 17, то вам нужно: if constexpr

#include <stack>
#include <queue>
#include <iostream>

using namespace std;

template<typename Cont>
void print_container(Cont& cont){
    while(!cont.empty()){
        if constexpr(std::is_same<Cont, stack<int>>::value){
            auto elem = cont.top();
            std::cout << elem << '\n';
        } else {
            auto elem = cont.front();
            std::cout << elem << '\n';
        }
        cont.pop();
    }
}

int main(int argc, char *argv[])
{
    stack<int> stk;
    stk.push(1);
    stk.push(2);
    stk.push(3);
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);

    std::cout << "print stack" << endl;
    print_container(stk);
    std::cout << "print queue" << endl;
    print_container(q);

    return 0;
}

Answer 2

Я ответил на свой вопрос, просто используя перегрузки.

template<typename Elem>
Elem get_first_elem(stack<Elem>& cont){
    return cont.top();
}
template<typename Elem>
Elem get_first_elem(queue<Elem>& cont){
    return cont.front();
}

template<typename Cont>
void print_container(Cont& cont){
    while(!cont.empty()){
        auto elem = get_first_elem(cont);
        cont.pop();
        std::cout << elem << '\n';
    }
}

Answer 3

проблема с

if(std::is_same<Cont, stack<int>>::value)
    ...
else
    +++

Если ... или +++ не скомпилируется, вы не сможете его использовать. Несмотря на то, что вы можете взять только одну ветвь или другую, обе ветви будут скомпилированы, и если синтаксис неверен, вы получите ошибку компилятора. С C ++ 17 if constexpr, хотя поведение отличается. Условие будет разрешено во время компиляции, и фактически будет скомпилирована только выбранная ветвь. Остальная часть кода отбрасывается. Переключение на этот код будет выглядеть как

template<typename Cont>
void print_container(Cont& cont){
    while(!cont.empty()){
        if constexpr(std::is_same<Cont, stack<int>>::value){
            auto elem = cont.top();
            std::cout << elem << '\n';
        } else {
            auto elem = cont.front();
            std::cout << elem << '\n';
        }
        cont.pop();
        std::cout << elem << '\n';
    }
}

Answer 4

Обе ветви оператора if - else должны быть скомпилированы, чего нет в вашем случае.Одно из многих возможных решений, которое основано на частичной специализации и должно работать даже в C ++ 98:

template <typename Cont>
struct element_accessor;

template <typename T>
struct element_accessor<std::stack<T>> {
   const T& operator()(const std::stack<T>& s) const { return s.top(); }
};

template <typename T>
struct element_accessor<std::queue<T>> {
   const T& operator()(const std::queue<T>& q) const { return q.front(); }
};

template<typename Cont>
void print_container(Cont& cont){
   while(!cont.empty()){
      auto elem = element_accessor<Cont>{}(cont);
      std::cout << elem << '\n';
      cont.pop();
   }
}

---

Решение C ++ 17 с if constexpr:

template<template<class> typename Cont, typename T>
void print_container(Cont<T>& cont){
   while(!cont.empty()){
      if constexpr (std::is_same_v<Cont<T>, std::stack<T>>) 
         std::cout << cont.top() << '\n';
      else if constexpr (std::is_same_v<Cont<T>, std::queue<T>>) 
         std::cout << cont.front() << '\n';
      cont.pop();
   }
}