[C++] [SFML 2.0] Range_error

// funkcje pomocnicze
const int ObjectsFilesCount = 1;

string ObjectsFileNames[ ObjectsFilesCount ] =
{
    "C:\\grafika\\samolocik\\obiekty\\kulka.png"
};

//////////////////////////////////////////////////////////////////

inline string RandObjectFileName()
{
    //return ObjectsFileNames[randint(1, ObjectsFilesCount) - 1]; // na razie jest tylko jeden obiekt, więc żeby uniknąć dzielenia przez 0:
    return ObjectsFileNames[ 0 ];
}

inline Vector2f RandObjectPos()
{
    int ub = 0 + UP_BOUND;
    int db = H - DOWN_BOUND;
   
    return Vector2f( - 10, randint( ub + 1, db + 1 ) - 1 ); // żeby uniknąć dzielenia przez 0
}

//...

// daję całą imp. klasy Object:
Object::Object( string filename, Vector2f p )
{
    tex.loadFromFile( filename );
    sp.setTexture( tex, true );
   
    pos = p;
    sp.setPosition( pos );
}

void Object::Do()
{
    sp.setPosition( pos );
}

void Object::Draw( RenderWindow & win )
{
    win.draw( sp );
}

//...

// tutaj funkcje klasy Map manipulujące obiektami
void Map::Objects()
{
    if( objs.size() < MAX_OBJS && randint( 0, 100 ) == 0 )
         objs.push_back( Object( RandObjectFileName(), RandObjectPos() ) );
   
    for( int i = 0; i < objs.size(); i++ )
    {
        if( objs[ i ].pos.x > w )
             objs.erase( objs.begin() + i );
       
        objs[ i ].pos.x += speed;
        objs[ i ].Do();
    }
}

void Map::Draw( RenderWindow & win )
{
    //...
   
    // narysuj obiekty
    for( int i = 0; i < objs.size(); i++ )
         objs[ i ].Draw( win );
   
}

// tu jest klasa wyrzucanego wyjatku
struct Range_error
    : out_of_range
{ // enhanced vector range error reporting
    int index;
    Range_error( int i )
        : out_of_range( "Range error: " + to_string( i ) )
        , index( i )
    { }
};

//...

// tu jest ulepszony wektor
template < class T > struct Vector
    : public std::vector < T >
{
    typedef typename std::vector < T >::size_type size_type;
   
    Vector() { }
    explicit Vector( size_type n )
        : std::vector < T >( n )
    { }
    Vector( size_type n, const T & v )
        : std::vector < T >( n, v )
    { }
    template < class I >
    Vector( I first, I last )
        : std::vector < T >( first, last )
    { }
   
    T & operator []( unsigned int i ) // rather than return at(i);
    {
        if( i < 0 || this->size() <= i ) throw Range_error( i );
       
        return std::vector < T >::operator []( i );
    }
    const T & operator []( unsigned int i ) const
    {
        if( i < 0 || this->size() <= i ) throw Range_error( i );
       
        return std::vector < T >::operator []( i );
    }
};

// disgusting macro hack to get a range checked vector:
#define vector Vector

//...

// a tu randint()
inline int randint( int max ) { return rand() % max; }

inline int randint( int min, int max ) { return randint( max - min ) + min; }