assignment of read-only location

enum { finish = 0, start = 300, wall = 9999, empty_cell = -1 };
typedef std::vector< std::vector< int > > dim;
typedef std::pair< int, int > coord;
typedef std::vector< coord > way;
 
class Wave
{   
    public:
        Wave( const int _W, const int _H );
        
        void setStartPosition( const int X, const int Y );
        void setEndPosition( const int X, const int Y );
        
        dim generateMap() const;
        void setMap( dim src );
        
        way getWay() const;
        dim getMap() const;
        
    private:
        const int W;
        const int H;
        
        coord start_position;
        coord finish_position;
        dim field;
};
 
Wave::Wave( const int _W, const int _H ) : W( _W ), H( _H ) {}
 
void Wave::setStartPosition( const int X, const int Y ) {
    start_position.first = X;
    start_position.second = Y;
}
 
void Wave::setEndPosition( const int X, const int Y ) {
    finish_position.first = X;
    finish_position.second = Y;
}
 
void Wave::setMap( dim src ) {
    field = src;
}
 
dim Wave::getMap() const {
    return field; 
}
 
dim Wave::generateMap() const {
    dim temp;
    std::vector< int > row;
    
    for( int y = 0; y < H; y++ ) {
        row.clear();
        int val;
        for( int x = 0; x < W; x++ ) {
            val = rand();
            
            if( val % 7 == 0) 
                val = wall;
            else
                val = empty_cell;
            
            row.push_back( val );
        }
        temp.push_back( row );
    }
    
    return temp;
}
 
way Wave::getWay() const {
    way oldWave;
    way wave;
    oldWave.push_back( coord(1, 1) );
    int nstep = 0;
    
    
    field[ start_position.first ][ start_position.second ] = nstep; //а вот здесь и ругается мол
                                                                                    //field константный, но почему я не знаю
    const int dx[] = { 0, 1, 0, -1 };
    const int dy[] = { -1, 0, 1, 0 };
    
    while( oldWave.size() > 0 ) {
        ++nstep;
        wave.clear();
        for( way::iterator i = oldWave.begin(); i != oldWave.end(); ++i ) {
            for( int d = 0; d < 4; ++d ) {
                int nx = i->first + dx[d];
                int ny = i->second + dy[d];
                if( field[nx][ny] == empty_cell ) {
                    wave.push_back( coord(nx, ny) );
                    field[nx][ny] = nstep;
                    if (nx == finish_position.first && ny == finish_position.second )
                        goto done;
                }
            }
        }
        oldWave = wave;
    }
 done:
 
    int x = finish_position.first;
    int y = finish_position.second;
    wave.clear();
    wave.push_back( coord(x, y) );
    
    while( field[x][y] != 0 ) {
        for( int d = 0; d < 4; ++d ) {
            int nx = x + dx[d];
            int ny = y + dy[d];
            if( field[x][y] - 1 == field[nx][ny] ) {
                x = nx;
                y = ny;
                wave.push_back( coord(x, y) );
                break;
            }
        }
    }
    return wave;
}

enum { finish = 0, start = 300, wall = 9999, empty_cell = -1 };
typedef std::vector< std::vector< int > > dim;
typedef std::pair< int, int > coord;
typedef std::vector< coord > way;
 
class Wave
{   
    public:     
        way getWay() const;
        
    private:
        dim field;
};
 
way Wave::getWay() const {
    way oldWave;
    way wave;
    oldWave.push_back( coord(1, 1) );
    int nstep = 0;
    
    
    field[ 1 ][ 1 ] = nstep;  //error
    
    return wave;
}
 
int main(int argc, char **argv)
{
    srand( time(NULL) );
    Wave w;
    way Way = w.getWay();
    return 0;
}