STL, Queue (в очереди изменить один элемент на другой?)

#include <iostream>
#include <queue>
 
template<typename T>
void Replace(T const& what, T const& replacement, std::queue<T>& queue)
{
    typename std::queue<T>::size_type queuesize = queue.size(), i;
    for(i = 0; i < queuesize; ++i)
    {
        if(queue.front() == what)
            queue.push(replacement);
        else
            queue.push(queue.front());
        queue.pop();
    }
}
 
template<typename T>
std::ostream& operator<<(std::ostream& ost, std::queue<T>& queue)
{
    typename std::queue<T>::size_type queuesize = queue.size(), i;
    for(i = 0; i < queuesize; ++i)
    {
        ost << queue.front() << std::endl;
        queue.push(queue.front());
        queue.pop();
    }
    return ost;
}
 
int main()
{
    std::queue<int> queue;
    queue.push(2);
    queue.push(33);
    queue.push(2);
    queue.push(55);
    queue.push(2);
    std::cout << queue << std::endl;
    Replace(2, 77, queue);
    std::cout << queue << std::endl;
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <deque>
#include <iostream>
#include <iterator>
#include <queue>
/////////////////////////////////////////////////////////////////////////////////////////
template<class  T>
class  T_queue_inheritor : public std::queue<T>
{
    typedef std::queue<T>                       T_base_queue;
    typedef typename T_base_queue::value_type   T_value_type;
public:
    //-----------------------------------------------------------------------------------
    T_queue_inheritor( const T_base_queue&  base_queue )
        :
        T_base_queue( base_queue )
    {}
    //-----------------------------------------------------------------------------------
    void  replace
            (
                const T_value_type&     old_value,
                const T_value_type&     new_value
            )
    {
        std::replace
            (
                c.begin     (),
                c.end       (),
                old_value,
                new_value
            );
    }
    //-----------------------------------------------------------------------------------
    void  print()
    {
        std::copy
            (
                c.begin                     (),
                c.end                       (),
                std::ostream_iterator<T>    (std::cout, "\t")
            );
 
        std::cout   <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
template<class  T>
void  replace_in_queue
    ( 
        std::queue<T>&                      queue_obj,
        typename std::queue<T>::value_type  old_value,
        typename std::queue<T>::value_type  new_value
    )
{
    T_queue_inheritor<T>    queue_inheritor( queue_obj );
    queue_inheritor.replace
        (
            old_value,
            new_value
        );
 
    queue_obj.swap( queue_inheritor );
}
/////////////////////////////////////////////////////////////////////////////////////////
template<class  T>
void  print_queue( const std::queue<T>&  queue_obj )
{
    T_queue_inheritor<T>    queue_inheritor( queue_obj );
    queue_inheritor.print();
}
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::queue<int>     T_int_queue;
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    T_int_queue     int_queue;
    int_queue.push(1);
    int_queue.push(9);
    int_queue.push(4);
    int_queue.push(5);
 
    std::cout   <<  "Исходная очередь:"
                <<  std::endl;
 
    print_queue( int_queue );
 
    replace_in_queue
        (
            int_queue,
            5,
            6
        );
 
    std::cout   <<  std::endl
                <<  "Очередь после изменения:"
                <<  std::endl;
 
    print_queue( int_queue );
}