Чем заменить указатель

#include <queue>
 
class SomeСlass
{
private:
    using Container = std::queue<int>;
    Container * p;
 
public:
    SomeСlass() : p{nullptr} {}
    SomeСlass(Container & r) : p{&r} {}
 
    void Reset(Container & r)
    {
        p = &r;
    }
};

SomeСlass some(new Container);

ты копай тут, а ты - тут, и тут. а я пока пойду, и узнаю, где нужно копать
(ц) армейский юмор.

if (stack.pop()){std::cout << "Removed";}

if(!stack.empty()) {
    stack.pop();
    std::cout << "Removed";
}

#pragma once
 
#include <string>
#include <queue>
#include <forward_list>
 
#include "Token.h"
#include "LexemeState.h"
#include "TableOfSymbols.h"
 
namespace clc::prs::lxr
{
    class Lexer
    {
    private:
        using WChar = std::wstring::value_type;
 
        LexemeState lexemeState;
        std::queue<WChar> * expression;
 
        TableOfSymbols<> tableOfSymbols;
 
        TokenEnum pastToken{Empty};
        bool IsUnary(TokenEnum);
 
        Token RefineToken(TokenEnum, std::wstring &);
 
        TokenEnum RefineFunction(std::wstring &);
        TokenEnum RefineOperation(WChar);
 
        std::forward_list<std::wstring> functionNames;
 
    public:
        Lexer();
        Lexer(std::queue<WChar> &, std::initializer_list<std::wstring> l =
                {L"sin", L"cos", L"tan", L"sqrt",} );
 
        Lexer(Lexer const &) = delete;
        Lexer(Lexer &&) = default;
 
        ~Lexer() = default;
 
        Lexer & operator=(Lexer const &) = delete;
        Lexer & operator=(Lexer &&) = default;
 
        Token GetToken();
 
        void Reset(std::queue<WChar> &);
        operator bool();
 
        TableOfSymbols<> & GetTableOfSymbol();
    };
 
    inline Lexer::Lexer() : expression{nullptr} {}
 
    inline Lexer::Lexer(
        std::queue<WChar> & i,
        std::initializer_list<std::wstring> l) :
            expression{&i},
            functionNames{l} {}
 
    inline void Lexer::Reset(std::queue<WChar> & q)
    {
        expression = &q;
        tableOfSymbols.Clear();
        pastToken = Empty;
    }
 
    inline Lexer::operator bool()
    {
        return expression != nullptr && !expression->empty();            
    }
 
    inline TableOfSymbols<> & Lexer::GetTableOfSymbol()
    {
        return tableOfSymbols;
    }
}

std::map<int,int> m{{1,2},{3,4}};
if (m.erase(3) != 0) {
    std::cout << "erased\n";
}

auto it = m.find(1);
if (it != m.end()) {
    m.erase(it);
    std::cout << "erased\n";
}

class SomeClass {
private:
    using Container = std::queue<int>;
    Container p;
 
public:
    SomeClass() {}
    SomeClass(Container & r) : p{r} {}
    SomeClass(Container && r) : p{std::move(r)} {}
    
    void Reset(Container & r) {
        p = r;
    }
 
    void Reset(Container && r) {
        p = std::move(r);
    }
};
 
std::queue<int> getQueue(std::initializer_list<int> lst) {
    std::queue<int> q;
    for(const int& el: lst) {
        q.push(el);
    }
    
    return q;
}
 
int main() {
    SomeClass s(getQueue({ 1, 2, 3, 4, 5 }));
    auto q = getQueue({ 1, 2, 3, 4, 5 });
    s.Reset(q);
    s.Reset(getQueue({ 1, 2, 3, 4, 5 }));
}