Re: Unsignedness of std::size_t

On Apr 15, 11:49 am, jeff_alexander...@yahoo.com wrote:


To clarify, I mean something like this:

#include <limits>
#include <vector>

template< typename size_type >
class debug_size_type
{
private:
    size_type m ;

public:
    debug_size_type( int i )
        :
        m(size_type(i))
    {
        assert(i >= 0) ;
    }

    debug_size_type( size_type i )
        :
        m(i)
    {
        // check -1 after conversion
        assert(i <= (std::numeric_limits<size_type>::max() >> 1)) ;
    }

    operator size_type()
    {
        return m ;
    }

    operator size_type() const
    {
        return m ;
    }
} ;

template< typename T >
class debug_vector
{
private:
    typedef std::vector<T> rep ;
    rep m ;

public:
    typedef debug_size_type<typename rep::size_type> size_type ;

    // ...
    // all member functions typographically identical to std::vector
    // ...

    debug_vector( size_type a )
        :
        m(a)
    {
    }

    T & operator[]( size_type i )
    {
        return m[i] ;
    }
} ;

int main()
{
    typedef debug_vector<double> container ;
    typedef unsigned int uint ;

    container a(10) ;

    // all produce an assertion failure inside container::size_type
    a[-1] = 4.0 ;
    a[uint(-1)] = 9.0 ;
    container c(-1) ;
    container d(uint(-1)) ;

    return 0 ;
}

This is the most satisfactory solution in my view. The assertions are
abstracted away, and we no longer need to litter our classes with
negative-number index/size checks. It is conceptually nicer that
a[-1] fails to create a size_type and thus operator[] is never called.
What do you think?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]