Кому интересно поломать голову

//где-то в классе
typedef std::set<ClassOne, ClassTwo> _Container;
 
// где-то в методе
return std::find(_Container::begin(), _Container::end(), predicate);

#include <iostream>
#include <deque>
 
template<typename T, class Container = std::deque<T, std::allocator<T>>>
class Stack : public Container
{
    using size_type = typename Container::size_type;
    using value_type = typename Container::value_type;
    using reference = typename Container::reference;
    using const_reference = typename Container::const_reference;
public:
    bool empty() const { return Container::empty(); }
    size_type size() const { return Container::size(); }
    value_type& top() { return Container::back(); }
    const value_type& top() const { return Container::back(); }
    void push(const value_type& val) { Container::push_back(val); }
    void pop() { Container::pop_back; }
private:
    void clear();
    template <class InputIterator>
    void assign (InputIterator first, InputIterator last);
    void assign (size_type n, const value_type& val);
    reference at (size_type n);
    const_reference at (size_type n) const;
    reference front();
    const_reference front() const;
    //... и закрыть кучу остальных функций членов std deque чтобы это таки стал стэк!
};
 
int main() 
{
    Stack<int> st;
    st.push(2);
    std::cout << st.empty() << std::endl;
    //st.std::deque<int>::clear(); // но прикинь - такой онанизм будет работать!
    std::cout << st.top() << std::endl;
    return 0;
}

#include <iostream>
#include <deque>
 
template<typename T, class Container = std::deque<T, std::allocator<T>>>
class Stack
{
    using size_type = typename Container::size_type;
    using value_type = typename Container::value_type;
    using reference = typename Container::reference;
    using const_reference = typename Container::const_reference;
    
    Container m_container;
public:
    bool empty() const { return m_container.empty(); }
    size_type size() const { return m_container.size(); }
    value_type& top() { return m_container.back(); }
    const value_type& top() const { return m_container.back(); }
    void push(const value_type& val) { m_container.push_back(val); }
    void pop() { m_container.pop_back; }
};
 
int main() 
{
    Stack<int> st;
    st.push(2);
    std::cout << st.empty() << std::endl;
    std::cout << st.top() << std::endl;
    return 0;
}

#include <iostream>
 
struct vector
{
    size_t size()const { return 0; }
    
    void reserve(const size_t) {}
};
 
struct der: protected vector //<--- суть: der не является vector, 
{                          //хотя и умеет все, что умеет vector  
    
    // просто указываем, что хотим переиспользовать
    using vector::vector;
    using vector::size;
    
    
};
 
 
void foo(vector&){}
 
int main()
{
    std::cout << "Hello, world!\n";
    
 
 
    // error: ‘vector’ is an inaccessible base of ‘der’    
    // поскольку der не является vector, то полиморфизм запрещен
    // vector* ololo = new der;
    // таким образом, любители трястись наl невиртуальным диструктором могут спать спокойно
    
    
    der d;
    
    // поскольку der не является vector, то приведение не допустимо:
    // error: ‘vector’ is an inaccessible base of ‘der’
    // foo(d);
    
    // error: ‘void vector::reserve(size_t)’ is inaccessible
    // мы не разрешали этот функционал
    //d.reserve(10);
    
    
    d.size(); //<--- этот функционал мы разрешили
}