template<class T> // DefaultConstructible, Assignable
class copiable
{
  T value_;
public:
  copiable() {}
  copiable(T const& src) { value_ = src; }
  copiable(copiable const& src) { value_ = src.value_; }

  copiable& operator=(T const& src) { value_ = src; } // нужен, чтобы избежать промежуточного конструирования
  copiable& operator=(copiable const& src) { value_ = src.value_; } // неявный оператор делает то же самое

  // всякие там функции доступа...
  T& get() { return value_; }
  T const& get() const { return value_; }

  operator T&() { return value_; }
  operator T const&() const { return value_; }
};

v.push_back(value);   // что делаем здесь без конструктора копии?
v[idx] = value;       // а здесь - без оператора присваивания?
*iter = value;
T value = *iter;

ГА>v.push_back(value);   // что делаем здесь без конструктора копии?
ГА>v[idx] = value;       // а здесь - без оператора присваивания?
ГА>*iter = value;
ГА>T value = *iter;
ГА>

#include <deque>
#include <iostream>

struct bar // copy constructable but not assignable
{
private:
    bar& operator=(const bar&);
    int m_n;
public:
    bar(int i) : m_n(i) {}
    void foo() {std::cout << m_n << '\n';}
};

int main()
{
    std::deque<bar> array;
    array.push_back(bar(1));
    array.push_back(bar(2));

    array[0].foo();
}

void _Insert(iterator _Where,
        const _Ty& _Val)
        {    // insert _Val at _Where
        _Nodeptr _Pnode = _Where._Mynode();
        _Nodeptr _Newnode = _Buynode(_Pnode, _Prevnode(_Pnode), _Val);
        _Incsize(1);
        _Prevnode(_Pnode) = _Newnode;
        _Nextnode(_Prevnode(_Newnode)) = _Newnode;
        }
_Nodeptr _Buynode(_Nodeptr _Next,
        _Nodeptr _Prev, const _Ty& _Val)
        {    // allocate a node and set links and value
        _Nodeptr _Pnode = this->_Alnod.allocate(1);
        _TRY_BEGIN
        new ((void *)_Pnode) _Node(_Next, _Prev, _Val);
        _CATCH_ALL
        this->_Alnod.deallocate(_Pnode, 1);
        _RERAISE;
        _CATCH_END
        return (_Pnode);
        }
struct _Node
        {    // list node
        _Node(_Genptr _Nextarg, _Genptr _Prevarg, const _Ty& _Myvalarg)
            : _Next(_Nextarg), _Prev(_Prevarg), _Myval(_Myvalarg)
            {    // construct a node with value
            }
        ...