Question

我是VC ++的新手，我需要在函数之间传递4个数组，所以我使用另一个数组来存储它们的指针。我做得对吗？

unsigned int* step1(...) {

    ...

    // save data arrays
    unsigned int* savedData = new unsigned int[4];
    savedData[0] = *data0;
    savedData[1] = *data1;
    savedData[2] = *data2;
    savedData[3] = *data3;
    return savedData;
}

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

    // read data arrays
    unsigned int* data0 = &savedData[0]; 
    unsigned int* data1 = &savedData[1];
    unsigned int* data2 = &savedData[2]; 
    unsigned int* data3 = &savedData[3];

    ...

}

Answer 1

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

我做得对吗？

好吧，为了在函数之间传递数据：是的，使用指针执行它是一个选项。但社区通常不鼓励它，因为它会使内存管理变得麻烦。

当你使用指向动态内存的指针时，你必须有一个清晰的图像，表明内存是在哪里创建的，哪里是内存将被删除，换句话说：内存的生命周期必须清晰明了，对于这个原因，通常不鼓励在函数之间传递指针。

例如，在你的情况下：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

Answer 2

使用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];

并添加一些代码，将使用这些函数。

Answer 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;
}

Answer 4

假设你真的想要你所写的东西（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 Container

如果这些数据chucks有任何特殊含义（如data1 = user ids，data2 = visitor ids，...）构建将命名它们的类或结构：

// 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

Answer 5

我尝试过Vyktor的解决方案，但它没有用。我终于使用普通的ol'数组（没有STL /向量）并使用以下代码从另一个父数组中保存/加载数组。

请注意，此方法被视为“遗留”，因为您必须使用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];

    ...

}

VC ++：在函数之间传递多个数组

5 个答案: