Question

这是我的代码：

int *myFunction()
{
    int A[3] = {1,2,3};
    return A;             //this will return the pointer to the first element in the array A
}

int main (void)
{
    int A[3];

    A = myfunction();     //A gets the return value of myFunction

    for(int j=0; j==2; j++)
    {
        B[j] = 2* A[j];   //doubles each value in the array
    }
    printf("%d",B);
    return 0;      
}

但这不起作用，因为返回的A不是实际的矢量。如何在主函数中获得实际向量{1,2,3}？

Answer 1

函数myFunction分配A，但此分配仅存在于函数的scope内。当函数返回时，保存A的内存被销毁。这意味着该函数正在返回一个指向尚未取消分配的内存的指针。

问题是变量A不会在函数外部持久存在。您可以使用全局变量或将指向缓冲区的指针传递到myFunction

全球变量法：

static int A[3];

int* myFunction()
{
    A[0] = 1; A[1] = 2; //etc
    return A;
}

在此示例中，由于A是全局的，A指向的内存会持续整个程序的整个生命周期。因此，返回指向它的指针是安全的......

作为旁注，全局变量可能不应该以这种方式使用......它有点笨拙。使用static关键字意味着在此模块（C文件）之外无法访问A。

指针方法：

void myFunction(a[3])
{
    a[0] = 1; a[1] = 2; //etc
}

int main()
{
    myA[3];
    myFunction(myA);
    // and continue to print array...
}

在此示例中，main()函数分配myA。函数执行时存在此变量（它是automatic variable）。指向数组的指针传递给函数，该函数填充数组。因此，main()函数可以从myFunction()获取信息。

使变量myA持久化的另一种方法是在堆上分配它。要做到这一点，你会做int *myA = malloc(sizeof(int) * NUMBER_OF_INTS_IN_ARRAY之类的事情。此记忆将持续存在，直到您使用free()专门对其进行描述，或者您的程序结束。

Answer 2

正在堆栈上创建

int A[3] = {1,2,3};，这是一个本地数组，它的内存可以在myFunction执行后再次使用。您必须在int A[3]内制作static myFunction或将其置于所有功能之外。另一种选择是在int A[3]内创建main并将A的地址传递给myFunction，以便myFunction可以直接修改A的内容

Answer 3

原样，你的代码还没有接近工作......你的for循环被破坏了，你在main中有未定义的变量，你有函数名称不匹配，你的打印是不是'无论如何都要做你想做的事......

由于您已经有未定义的行为导致的大问题，您无法在本地定义的函数之外访问A[]。最简单的纠正方法是在malloc()中使用动态内存A myFunction的某些内存，然后使用main和free()内存中的值当你完成了。

以下是修复其他语法问题的示例：

int *myFunction()
{
    int *A;
    A = malloc(3 * sizeof(int));
    A[0] = 1;
    A[1] = 2;
    A[2] = 3;
    return A;
}

int main (void)
{
    int *A = myFunction();     //A gets the return value of myFunction
    int B[3] = {0, 0, 0};
    int j;
    for(j=0; j<3; j++)
    {
        B[j] = 2* A[j];   //doubles each value in the array
    }
    free(A);
    printf("%d",B[0]);
    return 0;      
}

Answer 4

将要填充的数组作为参数传递给initisliser函数及其大小：

size_t myFunction(int * A, size_t s)
{
  int A_tmp[3] = {1,2,3};

  size_t i = 0;
  for (; i < s && i < sizeof(A_tmp)/sizeof(A_tmp[0]); ++i)
  {
    A[i] = A_tmp[i];
  }

  return i;
}

然后这样称呼它：

int main()
{
  int myA[3];
  size_t s = sizeof(myA)/sizeof(myA[0]);
  size_t n = myFunction(myA, s);
  if (n < s)
    fprintf(stderr, "Caution: Only the first %zu of %zu elements of A were initialised.\n", n, s);

  // and continue to print array...
}

Answer 5

#include <stdio.h>

int (*myFunction(void))[3]
{
    static int A[3] = {1,2,3};
    return &A;
}

int main (void){
    int (*A)[3], B[3];

    A = myFunction();

    for(int j=0; j<=2; j++)
    {
        B[j] = 2 * (*A)[j];
    }
    for(int j=0; j<3;++j)
        printf("%d ", B[j]);
    return 0;
}

如何从指针获取信息

5 个答案: