namespace std {
     struct input_iterator_tag {};
     struct output_iterator_tag {};
     struct forward_iterator_tag: public input_iterator_tag {};
     struct bidirectional_iterator_tag: public forward_iterator_tag {};
     struct random_access_iterator_tag: public bidirectional_iterator_tag {};
}

class reverse_iterator : public iterator

24.3.3/4 [Example: If a C++ program wants to define a bidirectional iterator for some data structure containing
double and such that it works on a large memory model of the implementation, it can do so with:

class MyIterator :
   public iterator<bidirectional_iterator_tag, double, long, T*, T&> {
                                // code implementing ++, etc.
};
Then there is no need to specialize the iterator_traits template. —end example]

template <class Item>
class SafeVector : public std::vector<Item>
{
    static Item m_FakeItem;
public:
    std::vector<Item>::const_reference operator[](
        std::vector<Item>::size_type Index) const
    {
        if (Index < 0 || Index >= size())
            return m_FakeItem;
        return (*(begin() + Index));
    }
    std::vector<Item>::reference operator[](
        std::vector<Item>::size_type Index)
    {
        if (Index < 0 || Index >= size())
            return m_FakeItem;
        return (*(begin() + Index));
    }
};

vector::at()

std::vector<int> *ptr = new std::vector<int>(10, 1);
...
(*ptr)[1] = 10;
...
delete ptr;

std::vector<int> arr(10, 1);
...

std::vector<Item>::const_reference operator[](
        std::vector<Item>::size_type Index) const
{
        if (Index < 0 || Index >= size())
                return m_FakeItem;
        return (*(begin() + Index));
}

5.3.5/3
In the first alternative (delete object), if the static type of the operand is 
different from its dynamic type, the static type shall be a base class of the 
operand’s dynamic type and the static type shall have a virtual destructor or 
the behavior is undefined.

B>>5.3.5/3
B>>In the first alternative (delete object), if the static type of the operand is 
B>>different from its dynamic type, the static type shall be a base class of the 
B>>operand’s dynamic type and the static type shall have a virtual destructor or 
B>>the behavior is undefined.
B>>

#include <iostream>

using namespace std;

struct base
{
   //virtual ~base() {}
};


class d : public base
{
public:
   static void* operator new(size_t sz);
   static void  operator delete(void* ptr, size_t sz);
};

void* d::operator new(size_t sz)
{
   cout << "d::new" << endl;
   //Возможно, своя хитрая реализация
   return ::operator new(sz);
}

void d::operator delete(void* ptr, size_t sz)
{
   cout << "d::delete" << endl;
   //Возможно, своя хитрая реализация
   ::operator delete(ptr);
}


int main () 
{
   base* pb = new d();
   delete pb;

   return 0;
}

namespace   std
{
template <class T, class A>
class OurVector
{
};

}

#define vector OurVector

pattern Null Object

*полиморфное удаление*

    int    *pFoo    = new int(0);
        ...
    delete pFoo;

#include "stdafx.h"

struct foo
{
    foo()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    ~foo()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};

struct bar
    :    public    foo
{
    bar()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    virtual ~bar()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};

struct poly_foo
{
    poly_foo()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    virtual ~poly_foo()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};

struct poly_bar
    :    public    poly_foo
{
    poly_bar()
    {
        std::cout << __FUNCTION__ << std::endl;
    }

    virtual ~poly_bar()
    {
        std::cout << __FUNCTION__ << std::endl;
    }
};


int _tmain(int argc, _TCHAR* argv[])
{
    {
        std::cout << " ------- Test bar ------- " << std::endl;
        foo    *pFoo_ = new bar;
        delete pFoo_;
    }

    {
        std::cout << " ------- Test poy_bar  ------- " << std::endl;

        poly_foo    *pFoo_ = new poly_bar;
        delete pFoo_;
    }

    return 0;
}

Tom>Вот сижу делаю ревью чужого кода:

...

Tom>Как вам такое? Я вот думаю как бы помягче обьяснить человеку, что он не прав.

const_reference []()