// ---------------------
// MethodOverloading.c++
// ---------------------

#include <cassert>  // assert
#include <cstddef>  // size_t
#include <iostream> // cout, endl

template <typename T>
class my_vector {
    private:
        std::size_t _s;
        T*          _a;

    public:
        my_vector (std::size_t s, const T& v = T()) :
                _s (s),
                _a (new T[_s]) {
            std::fill(begin(), end(), v);}

        ~my_vector () {
            delete [] _a;}

        T& at (std::size_t i) {
            my_vector<T>* const p = this;
            assert(p == this);
            return _a[i];}

        const T& at (std::size_t i) const {
            const my_vector<T>* const p = this;
            assert(p == this);
            return const_cast<my_vector<T>*>(this)->at(i);}

        T* begin () {
            return _a;}

        const T* begin () const {
            return _a;}

        T* end () {
            return _a + _s;}

        const T* end () const {
            return _a + _s;}};

int main () {
    using namespace std;
    cout << "MethodOverloading.c++" << endl;

    {
    const my_vector<int> x(10, 2);
    assert(x.at(1) == 2);
//  x.at(1) = 3;                   // doesn't compile
    }

    {
    my_vector<int> x(10, 2);
    assert(x.at(1) == 2);
    x.at(1) = 3;
    assert(x.at(1) == 3);
    }

    cout << "Done." << endl;
    return 0;}