如何使用3D char数组调整双指针2D char阵列的大小

Question

我不确定如何从char ***调整char ** 2d数组的大小。char ** 2D数组通过此调整大小函数如下所示。

这里说功能：

    resize_canvas(&C, 5, 6, 5, 10, 'e');

这通过以下代码。它正在打印出一个char ***，但不是我想要的大小。它必须能够从上述功能中调整到任何给定的大小：

    void resize_canvas(char*** Cp, int old_width, int old_height, int new_width, int new_height, char wc){
    int height = new_height;
    int width = new_width;
    int depth = 1;
    Cp = new char**[height];
    for(int i = 0; i < height; i++){
        Cp[i] = new char*[width];
        for(int j = 0; j < width; j++){
            Cp[i][j] = new char[depth];
            for(int z = 0; z < depth; ++z){
                Cp[i][j][z] = wc;
                cout << Cp[i][j][z];
            }
        }
        cout << endl;
    }
}

它没有给我我想要的东西。以前的char **阵列打印出来：

    // C:
    // ddddddd
    // ddddddd
    // ddddddd
    // ddddddd
    // ddddddd
    // ddddddd

我需要它可以调整大小，以便以后：

    // C:
    // ddddddeeee
    // ddddddeeee
    // ddddddeeee
    // ddddddeeee
    // ddddddeeee

这些是我以前分配和填充Char ** 2D数组的功能：

char** allocate_canvas(int width, int height){
    char **array;
    char temp = 'A';
    array = (char **)malloc(height* sizeof(char *));
    for (int i = 0; i < height; i++){
        array[i] = (char*)malloc(width* sizeof(char));
    }
    return array;
}
void wash_canvas(char** C, int width, int height, char wc){
    for(int i = 0; i < height; i++){
        for(int j = 0; j < width; j++){
            C [j][i] = wc;
        }
    }
}
void deallocate_canvas(char** C, int width){
    for(int i = 0; i < width; i++){
        free(C[i]);
        C[i] = NULL;
    }
    free(C);
}

Answer 1

由于您使用的是C ，因此可以将引用传递给指针。这是实现resize_canvas的一种方法。

void resize_canvas(char**& Cp,
                   int old_width, int old_height,
                   int new_width, int new_height, char wc)
{
   int height = new_height;
   int width = new_width;
   int depth = 1;
   // Allocate memory for the new array.
   char** newArray = new char*[height];
   for(int i = 0; i < height; i++)
   {
      newArray[i] = new char[width];
      for(int j = 0; j < width; j++){
         newArray[i][j] = wc;
      }
   }
   // Deallocate the old array.
   char** oldArray = Cp;
   for(int i = 0; i < old_height; i++)
   {
      delete [] oldArray[i];
   }
   delete [] oldArray;
   // Return the new array to the calling function.
   Cp = newArray;
}

话虽如此，最好使用代表Canvas的类。

class Canvas
{
   public:
     Canvas(int width, int height, char wc);
     void wash(char wc);
     void resize(int new_width, int new_height, char wc);
  private:
     // Private data can take different forms.
     // Best to use std::vector.
     std::vector<std::vector<char>> data;
};

Answer 2

我认为您的问题源于：

Cp = new char**[height];

就像按值通过值传递的任何参数一样，更新它将影响本地值，但不会返回您更改的内容。实际上，您采取了您所做的工作，然后从之前的2D字符阵列中拨出并将其扔掉，用新的 local 2D char数组代替它。您需要分配给由参数指向的内存，或：

*Cp = new char*[height];

Answer 3

，因为您已经有必要的功能可以使用，因此将它们重新授权。

//assuming that resize means (new_width > old_width)  and (new_height > old_height)
void resize_canvas(char*** Cp, int old_width, int old_height, int new_width, int new_height, char wc)
{
    //char*** Cp : here Cp is address of existing 2D array.

    //[1] Allocate the new array
    char **C_new = allocate_canvas(new_width, new_height);
    //[2] if the (new_width > old_width) and (new_height > old_height) then fill old elements with corresponding 'Cp[i][j]' and all the extra elements with 'wc'.
    int i, j;
    char **C_old = *Cp;  // now 'C_old' will point to you existing 2D array.
    //filling old elements
    for(i = 0; i < old_height; ++i)
    {
        for(j = 0; j < old_width; ++j)
        {
            C_new[i][j] = C_old[i][j];
        }
    }
    //[3] Deallocate the existing array
    deallocate_canvas(C_old, old_width);
    //[4] assign new array to old array
    *Cp = C_new;
    //filling new elements
    for(; i < new_height; ++i)
    {
        for(; j < new_width; ++j)
        {
            C_new[i][j]= wc;            
        }
        cout << endl;
    }
    //check the array by printing
    cout << endl;
    for(i = 0; i < new_height; ++i)
    {
        for(j = 0; j < new_width; ++j)
        {
            cout << C_new[i][j];
        }
        cout << endl;
    }
}