Стандарты и стили языков программирования

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
 
int main()
{
    std::vector<int> Vec((std::istream_iterator<int>(std::cin)),
        std::istream_iterator<int>());
    std::copy(Vec.begin(), Vec.end(), std::ostream_iterator<int>(std::cout, " "));
    std::vector<int>::iterator middle=Vec.end()-Vec.size()/2;
    Vec.insert(middle, 100);
    std::cout<<'\n';
    std::copy(Vec.begin(), Vec.end(), std::ostream_iterator<int>(std::cout, " "));
    return 0;
}

#include <string>
#include <iostream>
 
int main()
{
    std::string str;
    str.push_back(0x01);
    str.push_back(0x02);
    str.push_back(0x00);
    str.push_back(0x03);
    std::cout<<str.size()<<'\n';
    std::cout<<str<<'\n';
    char what[5];
    what[0]=0x01;
    what[1]=0x02;
    what[2]=0x00;
    what[3]=0x03;
    what[4]='\0';
    std::cout<<what<<'\n';
    return 0;
}

copy(v.begin(), v.end(), ostream_iterator <int> (cout, " "));

for (long i = 0; i < v.size(); i++) cout << v[i] << " ";

for(std::vector<int>::const_iterator iter=vec.begin(); iter != vec.end(); ++iter)
{
     std::cout<<' '<<*iter;
}
std::cout<<'\n';

void print(int one)
{
    std::cout<<' '<<one;
}
 
std::for_each(vec.begin(), vec.end(), print);
std::cout<<'\n';

std::for_each(vec.begin(), vec.end(), [](int el) {std::cout<<' '<<el;});

[](int el) {std::cout<<' '<<el;}

template<class _Ty1,
    class _Ty2> inline
    _Ty2 _Uninit_copy(_Ty1 _First, _Ty1 _Last, _Ty2 _Dest,
        _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag)
    {   // copy [_First, _Last) to raw _Dest, scalar type
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Dest);
    size_t _Count = (size_t)(_Last - _First);
    _Ty2 _Result = _Dest + _Count;
    if (_Count > 0)
        _CRT_SECURE_MEMMOVE(&*_Dest,
            _Count * sizeof (*_First), &*_First,
            _Count * sizeof (*_First)); // NB: non-overlapping move
    return (_Result);
    }

    vector(const _Myt& _Right)
        : _Mybase(_Right._Alval)
        {   // construct by copying _Right
        if (_Buy(_Right.size()))
            _TRY_BEGIN
            _Mylast = _Ucopy(_Right.begin(), _Right.end(), _Myfirst);
            _CATCH_ALL
            _Tidy();
            _RERAISE;
            _CATCH_END
        }

    template<class _Iter>
        pointer _Ucopy(_Iter _First, _Iter _Last, pointer _Ptr)
        {   // copy initializing [_First, _Last), using allocator
        return (_STDEXT unchecked_uninitialized_copy(_First, _Last,
            _Ptr, this->_Alval));
        }

template<class _InIt,
    class _FwdIt> inline
    _FwdIt unchecked_uninitialized_copy(_InIt _First, _InIt _Last,
        _FwdIt _Dest)
    {   // copy [_First, _Last) to raw _Dest
        return (_STD _Uninit_copy(_CHECKED_BASE(_First),
            _CHECKED_BASE(_Last), _Dest,
            _STD _Ptr_cat(_First, _Dest),
            _STD _Range_checked_iterator_tag()));
    }

template<class _Ty1,
    class _Ty2> inline
    _Ty2 _Uninit_copy(_Ty1 _First, _Ty1 _Last, _Ty2 _Dest,
        _Scalar_ptr_iterator_tag, _Range_checked_iterator_tag)
    {   // copy [_First, _Last) to raw _Dest, scalar type
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Dest);
    size_t _Count = (size_t)(_Last - _First);
    _Ty2 _Result = _Dest + _Count;
    if (_Count > 0)
        _CRT_SECURE_MEMMOVE(&*_Dest,
            _Count * sizeof (*_First), &*_First,
            _Count * sizeof (*_First)); // NB: non-overlapping move
    return (_Result);
    }

#define _CRT_SECURE_MEMMOVE(dest, destsize, source, count) ::memmove_s((dest), (destsize), (source), (count))

// Создаём вектор.
std::vector<int> vec1;
    
// Заполняем его чем-нить.
for (int i = 0; i < 10; i++)
    vec1.push_back(i);
 
// Копируем в другой вектор, исключая крайние элементы.
std::vector<int> vec2(vec1.begin() + 1, vec1.end() - 1);

                iterator erase(iterator Where)
                {
                        if(Where==end())
                                return Where;
                        Alloc.destroy(&(*Where));
                        stdext::unchecked_copy(Where+1, end(), Where);
                        --Size;
                        return Where;
                }
 
                iterator erase(iterator first, iterator last)
                {
                        if(first==last)
                                return end();
                        iterator ptr=stdext::unchecked_copy(last, end(), begin());
                        last=ptr;
                        Size-=last-first;
                        return first;
                }

    iterator erase(const_iterator _Where)
        {   // erase element at where
        if (_Where._Mycont != this
            || _Where._Myptr < _Myfirst || _Mylast <= _Where._Myptr)
            _DEBUG_ERROR("vector erase iterator outside range");
        _STDEXT unchecked_copy(_Where._Myptr + 1, _Mylast, _Where._Myptr);
        _Destroy(_Mylast - 1, _Mylast);
        _Orphan_range(_Where._Myptr, _Mylast);
        --_Mylast;
        return (iterator(_Where._Myptr, this));
        }

template<class _InIt,
    class _OutIt> inline
    _OutIt __CLRCALL_OR_CDECL unchecked_copy(_InIt _First, _InIt _Last, _OutIt _Dest)
    {   // copy [_First, _Last) to [_Dest, ...)
        return (_STD _Copy_opt(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
            _STD _Iter_random(_First, _Dest), _STD _Ptr_cat(_First, _Dest), _STD _Range_checked_iterator_tag()));
    }

template<class _InIt, class _OutIt, class _InOutItCat>
inline
    _OutIt __CLRCALL_OR_CDECL _Copy_opt(_InIt _First, _InIt _Last, _OutIt _Dest,
        _InOutItCat, _Nonscalar_ptr_iterator_tag, _Range_checked_iterator_tag)
    {   // copy [_First, _Last) to [_Dest, ...), arbitrary iterators
    _DEBUG_RANGE(_First, _Last);
    for (; _First != _Last; ++_Dest, ++_First)
        *_Dest = *_First;
    return (_Dest);
    }

    void _Destroy(pointer _First, pointer _Last)
        {   // destroy [_First, _Last) using allocator
        _Destroy_range(_First, _Last, this->_Alval);
        }

template<class _Alloc> inline
    void _Destroy_range(typename _Alloc::pointer _First,
        typename _Alloc::pointer _Last, _Alloc& _Al,
        _Scalar_ptr_iterator_tag)
    {   // destroy [_First, _Last), scalar type (do nothing)
    }

    void _Orphan_range(pointer _First, pointer _Last) const
        {   // orphan iterators within specified (inclusive) range
        _Lockit _Lock(_LOCK_DEBUG);
        const_iterator **_Pnext = (const_iterator **)&this->_Myfirstiter;
        while (*_Pnext != 0)
            if ((*_Pnext)->_Myptr < _First || _Last < (*_Pnext)->_Myptr)
                _Pnext = (const_iterator **)&(*_Pnext)->_Mynextiter;
            else
                {   // orphan the iterator
                (*_Pnext)->_Mycont = 0;
                *_Pnext = (const_iterator *)(*_Pnext)->_Mynextiter;
                }
        }