返回数组

Question

如何返回指向数组的指针并从中获取值？

int * getChange(int first[], int second[], int SIZE) { 
    int i = 0; 
    int * change = new int[2]; 
    for (i = 0; i < SIZE; i++) { 
     if (first[i] != second[i]) { 
      change[0] = first[i]; 
      change[1] = second[i]; 
     } 
     break; 
    } 
    return change; 
} 

function main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    int * change; 
    change = getChange(possibilities, myNumbers, 4); 
    printf("%i/%i\n", (change), (change+1)); 
} 

不幸的是，功能似乎返回地址，而不是值...

Answer 1

试图改变

printf("%i/%i\n", (change), (change+1)); 

到

printf("%i/%i\n", *(change), *(change+1)); 

在printf功能，你需要使用一个int作为参数，而不是一个int*。 change变量是一个指针。您必须使用*change，并使用指针算法，*(change + 1)

显然，不要忘记释放分配的内存。

Answer 2

printf("%i/%i\n", (change), (change+1)); 

这应该是：

printf("%d/%d\n", *change, *(change + 1)); 

Answer 3

int* functionReturningArray(int *inputArray, int size) 
{ 
    int*outputArray = new int[20]; 
    return outputArray; 
} 

但是，在C++和c样式数组中使用vector要好得多。因为它可以保护你免受很多错误的影响，并且使用矢量编写代码的速度更快。 也这样functionReturningArray不是很好，因为它只返回一个指向数组的第一个元素的指针，但不返回大小。您可以通过预定义他们传递指针给他们你的函数像这样返回的大小和指针（两个参数）：

void f(int**outputArray, int *size) 
{ 
    *outPutArray = new int[20]; 
    *size = 20; 
} 

而且它的外观与向量：

std::vector<int> func(const std::vector<int> &input) 
{ 
    std::vector<int> output; 
    output.push_back(5); 
    return output; 
} 

你也可以在堆上创建矢量并返回指向它的指针。 但是避免使用std :: vector - 使用std :: string来替代

Answer 4

我想我会写一点不同的（并且注意我在C++中只使用C概念 - 在C++中我几乎可以肯定做事情有点不同）：

void getChange(int *first, int *second, int SIZE, int *change) { 
    int i = 0; 
    for (i = 0; i < SIZE; i++) { 
     if (first[i] != second[i]) { 
      change[0] = first[i]; 
      change[1] = second[i]; 
      break; 
     } 
    } 

    return;  
} 

function main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    int change[2]; 
    getChange(possibilities, myNumbers, 4, change); 
    printf("%i/%i\n", change[0], change[1]); 
} 

如果分配change外面的getChange你解决潜在的内存泄漏问题。

Answer 5

在C++中，你不会使用数组（int[]或int*）来的，因为他们在几个方面都讨厌：你必须通过SIZE各地，他们通常异常不安全（你必须捕获异常，删除数组，然后重新抛出异常），并且很难正确使用它作为类成员。使用标准库容器或迭代器范围。

惯用的方式做你想要做的是使用迭代器和对什么：

template <typename IT_1, typename IT_2> 
std::pair<int,int> getChange(IT1 begin, IT1 end, IT2 begin2) 
{ 
    for (; begin != end; ++begin, ++begin2) 
    { 
    if (*begin != *begin2) return std::make_pair(*begin,*begin2); 
    } 
    return std::make_pair(0,0); 
} 

void main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    std::pair<int,int> change = getChange(possibilities, possibilities + 4, 
              myNumbers); 
    printf("%i/%i\n", change.first, change.second); 
} 

注意，第二序列（通过myNumbers）预计为至少只要是作为第一序列。如果你与迭代器和函数模板不舒服的是，你可以随时使用向量来代替：

std::pair<int,int> getChange(std::vector<int> a, std::vector<int> b) { 
    for (int i = 0; i < a.size() && i < b.size(); ++i) 
    { 
    if (a[i] != b[i]) return std::make_pair(a[i],b[i]); 
    } 
    return std::make_pair(0,0); 
} 

void main() { 
    int _myNumbers[] = {1, 0, 2, 3}; 
    int _possibilities[] = {0, 1, 2, 3}; 

    std::vector<int> myNumbers(_myNumbers,_myNuymbers+4), 
        possibilities(_possibilities,_possibilities+4); 

    std::pair<int,int> change = getChange(possibilities, myNumbers); 
    printf("%i/%i\n", change.first, change.second); 
} 

而后者似乎而非阵列版本更详细的（毕竟，它创建两个数组，然后复制将它们的值写入向量中），请记住从一个常量初始化一个数组是非常罕见的事情：大多数情况下，数组（和向量）是由一段代码专门用于动态初始化的。这样的代码通常可以用于数组和矢量，只需很少的更改。

而且，当然，如果您最终使用它们的话，您可以将typedef均设为std::pair<int,int>和std::vector<int>更短的名称。

Answer 6

正如前面所说，你的代码在很多层次上都是非常错误的。我会尽力解释。

首先，如果你想返回相同的数组，你为什么要创建一个新的？你想要做什么，到底是什么？

其次，你所做的新事物永远不会被释放。在main（）退出后，应用程序的所有内存都将被操作系统声明，但不应该依赖于此。

即Chowlett写正确的代码（+1是不错的，并指出了分配问题），所以我就通过你的代码，并指出东西

for(int i = 0 ; i < size i++) 
{ 
    if(first[i] != second[i]) 
    { 
     change[0] = first[i]; 
     change[1] = second[i]; 
    } 
    break; 
} 

一点不做你想做的事。它检查第一个[0]是否与第二个[0]不同，然后点击是否成立。你想要在if语句块内进行分解。

那么如果你想使用一个数组的内容，你必须用[]索引它，否则你引用数组的内存地址，它是索引。这意味着它一直说，你想要做

printf("%d/%d", changed[0], change[1]) 

在什么上面，使用C++向量是这种情况下比数组“更好”，我不认为这是正确的回答你的问题说： 。你似乎在学习如何使用数组，而数组是C甚至C++实际生活编码中最重要的部分。你会使用它们很多，它们比矢量更快，许多很多很多库都是用纯C编写的，所以你必须使用它们。

学习一点点指针算术，你会没事的。记住释放你分配的内存，这不是Java。记住，一个在

int a[3]; 

更像是一个

int *a; 

不是像一个

int a; 

这就解释了为什么你也可以做

printf("%d/%d", *changed, *(changed + 1)); 

阅读Kernighan和里奇。 快乐黑客

---