如何将内存的连续块（​​动态）添加到预先分配的动态内存

Question

I am working with Arduino. My main task is to divide the entire room into small grids and do a mapping of the obstacles in the room using ultrasonic sensors.
For that i wish to allocate memory dynamically. Now these sensors can detect only up to 4m. So i will divide that distance into blocks and allocate memory. But as the robo moves ahead it will discover more room and needs more memory appended to the previously allocated memory.

So this is a question of adding contiguous block of memory to a previously allocated memory.

This is a small part of the code that is related to the problem.

//max_x and max_y are the number of blocks in x and y direction respectively.

int **grid = new *int[max_x];              
for(int i = 0; i <max_x; i++)
{
    int grid[i] = new int[max_y];
}

void foo();   //stores some values in the previously allocated memory.

dist_y = get_y();      //returns blocks available in y direction.
dist_x = get_x();      //returns blocks available in x direction.
if((dist_y > max_y) | (dist_x > max_x))
{
    append_grid((max_x-dist_x),(max_y-dist_y));  //add these many number of blocks.
}  

So how to add more memory depending on the distance measured?

Answer 1

I think this is what you are trying to do

#include <iostream>
using namespace std;

int max_x=10;
int max_y=12;

int** changeXY( int** g, int newX, int newY ){
int** temp = new int*[newY];
for(int i = 0; i < newY; i++)
    temp[i] = new int[newX];
for( int y = 0; y < max_y; y++)    
    for( int x = 0; x < max_x; x++)
        temp[x][y] = g[x][y];
        delete[] g;
        return temp;
}
int main() {

//Its easier to think about what you are creating as a vector
//full of vectors rather than a grid. Here you are creating a 
//pointer to a string of pointers of size max_y
//or assigning the number of columns
int **grid = new int*[max_y];            

//here you are making a loop to add elements to the pointer
//array you just created. if the pointer syntax is confusing remember
//that "grid[i]" is equivalent to "*(grid + i)"
for(int i = 0; i < max_y; i++)
    grid[i] = new int[max_x];   

grid = changeXY(grid,22,20);
delete[] grid;
return 0;
}

There were a couple mistakes in your syntax. First of all, when you declare a dynamic memory, the syntax is "new int*[max_y]", you are effectively telling the compiler what type to specify. Second, when adding the other dimension in the loop, you are adding it to the grid. Not the first dimension.

OH, btw! the way I wrote this, there is no handling and unless max_y and max_x are global like they are in this example the changeXY() function will have to also include them in the input parameters. Hope this helps.

Answer 2

Now that i am aware of std::vector i think i can use it for this problem. I haven't posted the entire code because I think it will add to too much of details that are not relevant.

vector<vector<int> > grid;
dist_y = get_y();        //returns the number of blocks in Y direction
if(dist_y > threshold){
    forward();          //moves a step forward.
    dist_x = get_x();   //returns blocks available in X direction.
    vector<int> col;
    for(int i = 0; i < dist_x; i++) {
        col.push_back(1);   //1 indicates there is free space there.
    }
    grid.push_back(col);
}  

Repeating this loop will keep adding elements as required.