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

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

执行您尝试做的事的惯用方法是使用迭代器和对：

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 3

如前所述，您的代码在很多层面都是非常错误的。我会试着解释一下。

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

其次，你所创造的新东西永远不会自由。在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和ritchie。快乐的黑客

Answer 4

我想我的写法有点不同（请注意我在这里坚持使用C-only概念 - 在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

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

这应该是：

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

Answer 6

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代替

返回数组

6 个答案: