namespace std { //you should almost never ever do this.    template < typename value_t >    class vector;    template < typename value_t >    class _Impl_vector_iterator {        friend class vector< value_type >;    public:        typedef value_t value_type;    private:        value_type * data ;        _Impl_vector_iterator ( value_type * data )            : data( data )        {        }    public:        bool operator==( const _Impl_vector_iterator & other ) const {            return data == other.data;        }        //...    };    template < typename value_t >    class vector {    public:        typedef std::size_t size_type;        typedef value_t value_type;        typedef _Impl_vector_iterator< value_type > iterator;        typedef _Impl_vector_iterator< const_value_type > const_iterator;    private:        size_type m_size; //I don't like pimpls for the most part, but...        value_type * data;    public:        size_type size( void ) const { //...people should use this function...            return m_size; //...so this is one of the two or three uses absolutely needed.        }        iterator begin( void ) {            return iterator( data ); //note: uses the private ctor, which is why we're a friend.        }        iterator end( void ) {            return iterator( data + size() ); //note: uses the private ctor again        }        const_iterator begin( void ) const {            return const_iterator( data );        }        const_iterator end( void ) const {            return const_iterator( data + size() ); //note: we use size() instead of m_size whenever possible.        }        //...    };}