VC :在功能之间传递多个数组

为了完成先前的有效答案，我将尝试扩展答案：

我做得正确吗？

好吧，为了在功能之间传递数据：是的，使用指针进行操作。但是社区通常会灰心，因为它使记忆管理变得麻烦。

当您使用指向动态内存的指针时，您必须清楚地了解创建内存的位置以及在何处删除内存的位置，换句话说：内存的生命周期必须清晰明了这个原因，通常不建议通过函数之间的指针。

例如，在您的情况下：unsigned int* step1(...)函数返回指针，但要查看它，新的程序员或与您一起工作的人不会判断返回的指针是否是动态内存，并且是否调用step1必须delete或delete []通话后的内存，unsigned char* step2(unsigned int* savedData, ...)也是如此，并且会更令人困惑和麻烦，因为有人会问：step2会更改savedData通过？

为了解决step2问题，您可以将功能更改为：

unsigned char* step2(const unsigned int* const savedData, ...)

通过添加const，您可以说："嘿！step2不会更改savedData的内容，也不会更改其指向的地址"。

但是所有以前的文本都是没有用的，因为没有解决最重要的问题：释放内存的地方？

在step1中，您正在动态创建内存，在step2中读取此内存，但是... delete隐藏在您不粘贴的代码中的某个地方？还是有一个step3等待记忆？

为了避免所有这些内存头痛，通常建议使用STL容器，例如std::vector，在您的情况下，容器将为您处理内存管理：

typedef std::vector<int> intvector;
typedef std::vector<intvector> intintvector;
void step1(intintvector &Data, ...) {
    ...
    // create data arrays
    intvector data0, data1, data2, data3;
    // fill data0, data1, data2, data3
    // ...
    // save data arrays.
    Data.push_back(data0);
    Data.push_back(data1);
    Data.push_back(data2);
    Data.push_back(data3);
}
void step2(const intintvector &savedData, ...) {
    // read data arrays
    intvector data0 = savedData[0]; 
    intvector data1 = savedData[1];
    intvector data2 = savedData[2]; 
    intvector data3 = savedData[3];
    // ...
}

简要摘要：如果您不照顾动态内存，则无法正确使用指针部分，因此，您必须解决此问题或委派到STL容器中。

希望它有帮助！：D

使用std :: vector。

std::vector<int> data;
data.push_back(data0);
data.push_back(data1);
data.push_back(data2);
data.push_back(data3);

和

int data0 = data[0];
int data1 = data[1];
int data2 = data[2];
int data3 = data[3];

并添加一些代码，其中将使用这些功能。

您将需要一系列指针，例如：

//The function that takes the array
void foo( char ** data )
{
    std::cout << data[0];
    std::cout << data[1];
    std::cout << data[2];
}
main()
{
    char * str = "aaa";
    char * str1 = "sss";
    char * str2 = "ddd";
    char ** res = new char *[3];//here's your array that has 3 elements each of which is a pointer.
    res[0]=str;
    res[1]=str1;
    res[2]=str2;
    foo( res );
    return 0;
}

输出将为

aaasssddd

一种更好的方法：

最好使用STL容器而不是原始指针，因为它们更容易使用。使用指针，它将以相同的方式工作：

void foo( std::vector< char * >vec )
{
    std::cout << vec[0];
    std::cout << vec[1];
    std::cout << vec[2];
}
main()
{
    char * str = "aaa";
    char * str1 = "sss";
    char * str2 = "ddd";
    std::vector< char * >vec;
    vec.push_back(str);
    vec.push_back(str1);
    vec.push_back(str2);
    foo( vec );
return 0;
}

进一步改进的方法：

最后，最好的方法是使用字符串：

void foo( std::vector< std::string >vec )
{
    std::cout << vec[0];
    std::cout << vec[1];
    std::cout << vec[2];
}
main()
{
    std::string str = "aaa";
    std::string str1 = "sss";
    std::string str2 = "ddd";
    std::vector< std::string >vec;
    vec.push_back(str);
    vec.push_back(str1);
    vec.push_back(str2);
    foo( vec );
return 0;
}

假设您确实想要所写的内容（4个阵列分组为一个），首先您需要4个数组，例如int：

int data1[] = {1,2,3,4};
int data2[] = {5,6,7,8,9,10};
int *data3; // Let's say those two were allocated by malloc/new
int *data4;
// Now array that will contain those values
int **data = new (int*)[4]; // int * = your datatype (array of ints)
                            // (int*)[] = array of arrays of ints
data[0] = data1;
data[1] = data2;
data[2] = data3;
data[3] = data4;

// And reverse function
data1 = data[0];
data2 = data[1];
data3 = data[2];
data4 = data[3];

几个注：

• 如果您想将这些"数组"可重新使用（或在时间后使用超过4个项目）使用std::vector或其他STL容器

• 如果这些数据Chucks具有任何特殊含义（例如data1 =用户ID，data2 =访问者ID，...）构建类别或结构将其命名：

  // In C:
  struct user_data{
     int *user_ids;
     int *visitor_ids;
     char **unregistered_user_names; // Feel free to use another types
  }
  // In C++
  class UserData {
      std::vector<int> userIds;
      std::vector<int> visitorIds;
      std::vector<std::string> unregisteredUserNames;
   }
  

• 一旦用new unsigned int [4]分配数据，请不要忘记delete [] array

的免费内存

我尝试了Vyktor的解决方案，但它不起作用。我终于使用普通的ol'arrays（没有stl/vector）来工作，并使用以下代码从另一个父数组保存/加载数组。

请注意，此方法被视为"遗产"，因为您必须使用delete [] myArray语法手动将数组分配。

unsigned int** step1(...) {
    ...
    // save data arrays
    unsigned int** savedData = new unsigned int*[4]; // ** means pointer to a pointer
    savedData[0] = data0; // transfer the pointer value straight
    savedData[1] = data1;
    savedData[2] = data2;
    savedData[3] = data3;
    return savedData;
}
unsigned char* step2(unsigned int** savedData, ...) { /// input is pointer to pointer
    // read data arrays
    unsigned int* data0 = savedData[0]; // read pointer straight
    unsigned int* data1 = savedData[1];
    unsigned int* data2 = savedData[2]; 
    unsigned int* data3 = savedData[3];
    ...
}