0

我对 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];

    ...

}
4

5 回答 5

3

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

我做对了吗？

好吧，为了在函数之间传递数据：是的，使用指针是一种选择。但是社区通常不鼓励它，因为它给内存管理带来了麻烦。

当您使用指向动态内存的指针时，您必须清楚地了解创建内存的位置和删除内存的位置，换句话说：内存的生命周期必须清晰明了，因此，通常不鼓励在函数之间传递指针。

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

于 2012-10-25T07:06:50.400 回答
1

您将需要一个指针数组，例如：

//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;
}
于 2012-10-25T06:19:24.673 回答
1

假设您真的想要您所写的内容（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 容器

  • 如果这些数据夹具有任何特殊含义（例如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

于 2012-10-25T06:42:56.807 回答
1

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

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

于 2012-10-25T06:17:59.547 回答
0

我尝试了 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];

    ...

}
于 2012-10-25T08:45:43.430 回答