My attempt at an immutable container view in C++

I have this very simple template:

#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <list>
#include <set>
#include <vector>

template<class Container>
class ImmutableContainerView {
private:
    Container& my_container;
public:
    ImmutableContainerView(Container& container) :
    my_container {container} {}

    typename Container::const_iterator cbegin() const {
        return my_container.cbegin();
    }

    typename Container::const_iterator cend() const {
        return my_container.cend();
    }

    typename Container::const_reverse_iterator crbegin() const {
        return my_container.crbegin();
    }

    typename Container::const_reverse_iterator crend() const {
        return my_container.crend();
    }

    typename Container::size_type size() const {
        return my_container.size();
    }

    bool empty() const {
        return my_container.empty();
    }
};

int main(int argc, const char * argv[]) {
    std::initializer_list<int> il = { 1, 2, 4, 5, 6 };

    std::list<int>   my_list   = il;
    std::set<int>    my_set    = il;
    std::vector<int> my_vector = il;

    ImmutableContainerView<std::list<int>>   my_immutable_list(my_list);
    ImmutableContainerView<std::set<int>>    my_immutable_set(my_set);
    ImmutableContainerView<std::vector<int>> my_immutable_vector(my_vector);

    // Iterators:
    std::ostream_iterator<int> out_it (std::cout, ", ");
    std::copy(my_immutable_list.cbegin(), my_immutable_list.cend(), out_it);
    std::cout << "\n";

    std::copy(my_immutable_set.cbegin(), my_immutable_set.cend(), out_it);
    std::cout << "\n";

    std::copy(my_immutable_vector.cbegin(), my_immutable_vector.cend(), out_it);
    std::cout << "\n";

    // Reversed iterators:
    std::copy(my_immutable_list.crbegin(), my_immutable_list.crend(), out_it);
    std::cout << "\n";

    std::copy(my_immutable_set.crbegin(), my_immutable_set.crend(), out_it);
    std::cout << "\n";

    std::copy(my_immutable_vector.crbegin(), my_immutable_vector.crend(), out_it);
    std::cout << "\n";

    // Size:
    std::cout << my_immutable_list.size() << "\n";
    std::cout << my_immutable_set.size() << "\n";
    std::cout << my_immutable_vector.size() << "\n";

    // Empty:
    std::cout << std::boolalpha;
    std::cout << my_immutable_list.empty() << "\n";
    std::cout << my_immutable_set.empty() << "\n";
    std::cout << my_immutable_vector.empty() << "\n";

    return 0;
}

I would like to hear comments on how to improve it. In particular, is it possible to do some metaprogramming trickery such that it can adapt to different containers; for example, it could provide operator[size_t] for std::vector, but find for std::set?