// ---------------------------
// ConstructorsDestructors.c++
// ---------------------------

#include <algorithm> // copy, equal, fill
#include <cassert>   // assert
#include <cstddef>   // size_t
#include <iostream>  // cout, endl
#include <iterator>  // distance

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

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

        template <typename II>
        my_vector (II b, II e) :
                _s (std::distance(b, e)),
                _a (new T[_s]) {
            std::copy(b, e, begin());}

        ~my_vector () {
            delete [] _a;}

        T* begin () {
            return _a;}

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

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

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

        std::size_t size () const {
            return _s;}};

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

    {
    const my_vector<double> x(10);
    assert(x.size() == 10);
    }

    {
    const my_vector<double> x(10, 2.34);
    assert(x.size() == 10);
    }

    {
    const long a[] = {2, 3, 4};
    const int  s   = sizeof(a) / sizeof(a[0]);
    const my_vector<double> x(a, a + s);
    assert(equal(x.begin(), x.end(), a));
    }

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