我是C的新手，我需要一些处理数组的方法的帮助。来自Java编程，我习惯于能够说int [] method()以返回数组。但是，我发现使用C时，必须在返回数组时使用指针。作为一个新的程序员，我真的根本不理解这一点，即使我已经查看了许多论坛。
基本上，我正在尝试编写一个在C中返回char数组的方法。我将使用数组提供方法（让我们称之为returnArray）。它将从前一个数组创建一个新数组并返回指向它的指针。我只是需要一些关于如何启动它的帮助以及如何在从数组发出指针后读取指针。任何帮助解释这一点是值得赞赏的。
数组返回功能的建议代码格式
char *returnArray(char array []){
char returned [10];
//methods to pull values from array, interpret them, and then create new array
return &(returned[0]); //is this correct?
}
函数调用者
int main(){
int i=0;
char array []={1,0,0,0,0,1,1};
char arrayCount=0;
char* returnedArray = returnArray(&arrayCount); ///is this correct?
for (i=0; i<10;i++)
printf(%d, ",", returnedArray[i]); //is this correctly formatted?
}
我还没有测试过这个，因为我的C编译器目前还没有工作，但我想弄清楚
答案 0 :(得分：190)
你不能从C中的函数返回数组。你也不能（不应该）这样做：
char *returnArray(char array []){
char returned [10];
//methods to pull values from array, interpret them, and then create new array
return &(returned[0]); //is this correct?
}
returned，并且一旦它离开其声明范围，即在函数返回时，对它的引用将变为无效。
您需要动态分配函数内部的内存或填充调用者提供的预分配缓冲区。
选项1：
动态分配函数内部的内存（负责解除分配ret的调用者）
char *foo(int count) {
char *ret = malloc(count);
if(!ret)
return NULL;
for(int i = 0; i < count; ++i)
ret[i] = i;
return ret;
}
这样称呼：
int main() {
char *p = foo(10);
if(p) {
// do stuff with p
free(p);
}
return 0;
}
选项2：
填充调用者提供的预分配缓冲区（调用者分配buf并传递给函数）
void foo(char *buf, int count) {
for(int i = 0; i < count; ++i)
buf[i] = i;
}
并称之为：
int main() {
char arr[10] = {0};
foo(arr, 10);
// No need to deallocate because we allocated
// arr with automatic storage duration.
// If we had dynamically allocated it
// (i.e. malloc or some variant) then we
// would need to call free(arr)
}
答案 1 :(得分：24)
C对数组的处理非常与Java不同，你必须相应地调整你的思路。 C中的数组不是第一类对象（也就是说，数组表达式在大多数情况下都不会保留它的“数组”）。在C中，类型为“{元素数组T”的表达式将被隐式转换（“衰减”）为“指向T的指针”类型的表达式，除非数组表达式是sizeof或一元&运算符的操作数，或者数组表达式是否用于初始化声明中的另一个数组的字符串文字。
除此之外，这意味着您无法将数组表达式传递给函数，并将作为数组类型接收;该函数实际上接收指针类型：
void foo(char *a, size_t asize)
{
// do something with a
}
int bar(void)
{
char str[6] = "Hello";
foo(str, sizeof str);
}
在对foo的调用中，表达式str已从char [6]类型转换为char *，这就是foo的第一个参数被声明的原因char *a代替char a[6]。在sizeof str中，由于数组表达式是sizeof运算符的操作数，因此它不会转换为指针类型，因此您将获得数组中的字节数（6）。
如果你真的感兴趣，你可以阅读Dennis Ritchie的The Development of the C Language来了解这种治疗的来源。
结果是函数不能返回数组类型，这很好，因为数组表达式也不能作为赋值的目标。
最安全的方法是让调用者定义数组，并将其地址和大小传递给应该写入它的函数：
void returnArray(const char *srcArray, size_t srcSize, char *dstArray, char dstSize)
{
...
dstArray[i] = some_value_derived_from(srcArray[i]);
...
}
int main(void)
{
char src[] = "This is a test";
char dst[sizeof src];
...
returnArray(src, sizeof src, dst, sizeof dst);
...
}
另一种方法是函数动态分配数组并返回指针和大小：
char *returnArray(const char *srcArray, size_t srcSize, size_t *dstSize)
{
char *dstArray = malloc(srcSize);
if (dstArray)
{
*dstSize = srcSize;
...
}
return dstArray;
}
int main(void)
{
char src[] = "This is a test";
char *dst;
size_t dstSize;
dst = returnArray(src, sizeof src, &dstSize);
...
free(dst);
...
}
在这种情况下，调用者负责使用free库函数释放数组。
请注意，上面代码中的dst是指向char的简单指针，而不是指向char数组的指针。 C的指针和数组语义是这样的，您可以将下标运算符[]应用于数组类型或指针类型的表达式; src[i]和dst[i]都将访问数组的i元素（即使src只有数组类型）。
你可以声明指向T的N元素数组的指针并做类似的事情：
char (*returnArray(const char *srcArr, size_t srcSize))[SOME_SIZE]
{
char (*dstArr)[SOME_SIZE] = malloc(sizeof *dstArr);
if (dstArr)
{
...
(*dstArr)[i] = ...;
...
}
return dstArr;
}
int main(void)
{
char src[] = "This is a test";
char (*dst)[SOME_SIZE];
...
dst = returnArray(src, sizeof src);
...
printf("%c", (*dst)[j]);
...
}
以上几个缺点。首先，旧版本的C期望SOME_SIZE是一个编译时常量，这意味着该函数只能使用一个数组大小。其次，在应用下标之前必须取消引用指针，这会使代码变得混乱。当您处理多维数组时，指向数组的指针会更好。
答案 2 :(得分：8)
这种美味邪恶的实施怎么样？
array.h
#define IMPORT_ARRAY(TYPE) \
\
struct TYPE##Array { \
TYPE* contents; \
size_t size; \
}; \
\
struct TYPE##Array new_##TYPE##Array() { \
struct TYPE##Array a; \
a.contents = NULL; \
a.size = 0; \
return a; \
} \
\
void array_add(struct TYPE##Array* o, TYPE value) { \
TYPE* a = malloc((o->size + 1) * sizeof(TYPE)); \
TYPE i; \
for(i = 0; i < o->size; ++i) { \
a[i] = o->contents[i]; \
} \
++(o->size); \
a[o->size - 1] = value; \
free(o->contents); \
o->contents = a; \
} \
void array_destroy(struct TYPE##Array* o) { \
free(o->contents); \
} \
TYPE* array_begin(struct TYPE##Array* o) { \
return o->contents; \
} \
TYPE* array_end(struct TYPE##Array* o) { \
return o->contents + o->size; \
}
的main.c
#include <stdlib.h>
#include "array.h"
IMPORT_ARRAY(int);
struct intArray return_an_array() {
struct intArray a;
a = new_intArray();
array_add(&a, 1);
array_add(&a, 2);
array_add(&a, 3);
return a;
}
int main() {
struct intArray a;
int* it;
int* begin;
int* end;
a = return_an_array();
begin = array_begin(&a);
end = array_end(&a);
for(it = begin; it != end; ++it) {
printf("%d ", *it);
}
array_destroy(&a);
getchar();
return 0;
}
答案 3 :(得分：6)
在您的情况下，您正在堆栈上创建一个数组，一旦离开函数范围，该数组将被释放。相反，创建一个动态分配的数组并返回指向它的指针。
char * returnArray(char *arr, int size) {
char *new_arr = malloc(sizeof(char) * size);
for(int i = 0; i < size; ++i) {
new_arr[i] = arr[i];
}
return new_arr;
}
int main() {
char arr[7]= {1,0,0,0,0,1,1};
char *new_arr = returnArray(arr, 7);
// don't forget to free the memory after you're done with the array
free(new_arr);
}
答案 4 :(得分：6)
我并不是说这是给定问题的最佳解决方案或首选解决方案。但是，记住函数可以返回结构可能很有用。虽然函数不能返回数组，但是数组可以用结构包装，函数可以返回结构，从而携带数组。这适用于固定长度的数组。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef
struct
{
char v[10];
} CHAR_ARRAY;
CHAR_ARRAY returnArray(CHAR_ARRAY array_in, int size)
{
CHAR_ARRAY returned;
/*
. . . methods to pull values from array, interpret them, and then create new array
*/
for (int i = 0; i < size; i++ )
returned.v[i] = array_in.v[i] + 1;
return returned; // Works!
}
int main(int argc, char * argv[])
{
CHAR_ARRAY array = {1,0,0,0,0,1,1};
char arrayCount = 7;
CHAR_ARRAY returnedArray = returnArray(array, arrayCount);
for (int i = 0; i < arrayCount; i++)
printf("%d, ", returnedArray.v[i]); //is this correctly formatted?
getchar();
return 0;
}
我邀请评论这项技术的优点和缺点。我没有打算这样做。
答案 5 :(得分：4)
您可以使用堆内存（通过 malloc（）调用）来执行此操作，就像此处报告的其他答案一样，但您必须始终管理内存（使用 free（）函数每次你打电话给你的功能）。 您也可以使用静态数组：
char* returnArrayPointer()
{
static char array[SIZE];
// do something in your array here
return array;
}
您可以使用它而不必担心内存管理。
int main()
{
char* myArray = returnArrayPointer();
/* use your array here */
/* don't worry to free memory here */
}
在此示例中，您必须在数组定义中使用static关键字将应用程序设置为数组生命周期，因此在返回语句后不会销毁它。 当然，通过这种方式，您可以在整个应用程序生命周期中占用内存中的SIZE字节，因此请正确调整大小！
答案 6 :(得分：2)
您的方法将返回一个严重失败的本地堆栈变量。要返回一个数组，在函数外部创建一个数组，将其按地址传递给函数，然后修改它，或者在堆上创建一个数组并返回该变量。两者都可以，但第一个不需要任何动态内存分配来使其正常工作。
void returnArray(int size, char *retArray)
{
// work directly with retArray or memcpy into it from elsewhere like
// memcpy(retArray, localArray, size);
}
#define ARRAY_SIZE 20
int main(void)
{
char foo[ARRAY_SIZE];
returnArray(ARRAY_SIZE, foo);
}
答案 7 :(得分：0)
您可以使用以下代码：
char *MyFunction(some arguments...)
{
char *pointer = malloc(size for the new array);
if (!pointer)
An error occurred, abort or do something about the error.
return pointer; // Return address of memory to the caller.
}
执行此操作时，稍后可以通过将地址传递给free来释放内存。
还有其他选择。例程可能会返回指向某个现有结构的数组（或数组的一部分）的指针。调用者可以传递一个数组，例程只是写入数组，而不是为新数组分配空间。