使用C返回数组
我对C比较陌生,我需要一些处理数组的方法的帮助。来自Java编程,我习惯于说使用C返回数组,c,arrays,pointers,char,C,Arrays,Pointers,Char,我对C比较陌生,我需要一些处理数组的方法的帮助。来自Java编程,我习惯于说int[]method(),以便返回数组。然而,我发现使用C时,在返回数组时必须使用数组指针。作为一个新的程序员,我真的一点也不理解这一点,即使我浏览了很多论坛 基本上,我正在尝试编写一个方法,用C语言返回一个char数组。我将为该方法(我们称之为returnArray)提供一个数组。它将从以前的数组创建一个新数组,并返回指向该数组的指针。我只是需要一些关于如何开始这方面的帮助,以及如何在指针被发送出数组后读取指针。任何
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?
}
函数的调用方
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?
}
intmain(){
int i=0;
字符数组[]={1,0,0,0,1,1};
字符数组计数=0;
char*returnedArray=returnArray(&arrayCount);///这是否正确?
对于(i=0;i在本例中,您正在堆栈上创建一个数组,一旦离开函数作用域,该数组将被释放。相反,创建一个动态分配的数组并返回指向它的指针
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);
}
char*returnArray(char*arr,int size){
char*new_arr=malloc(sizeof(char)*size);
对于(int i=0;i
您的方法将返回一个失败严重的本地堆栈变量。若要返回数组,请在函数外部创建一个数组,按地址将其传递到函数中,然后对其进行修改,或者在堆上创建一个数组并返回该变量。这两种方法都可以工作,但第一种方法不需要任何动态内存分配即可使其正常工作。
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);
}
不能从C中的函数返回数组。也不能(不应该)执行以下操作:
返回的
是使用自动存储持续时间创建的,一旦它离开其声明范围,即当函数返回时,对它的引用将变得无效
您需要动态分配函数内部的内存,或者填充调用者提供的预分配缓冲区
选项1:
动态分配函数内部的内存(负责解除分配的调用方ret
)
选项2:
填充调用者提供的预分配缓冲区(调用者分配buf
并传递给函数)
您可以使用如下代码:
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来释放内存
还有其他选项。例程可能返回指向数组(或数组的一部分)的指针这是某些现有结构的一部分。调用方可能会传递一个数组,而例程只是写入数组,而不是为新数组分配空间。C对数组的处理与Java的处理非常不同,您必须相应地调整思维。C中的数组不是一流对象(也就是说,数组表达式在大多数上下文中不保留其“数组性”)。在C中,“N元素数组的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[6]
。在sizeof str
中,由于数组表达式是sizeof
运算符的操作数,因此它不会转换为指针类型,因此可以获得数组中的字节数(6)
如果你真的感兴趣,你可以读丹尼斯·里奇的书来了解这种疗法的来源
结果是函数不能返回数组类型,这很好,因为数组表达式也不能作为赋值的目标
最安全的方法是调用方定义数组,并将其地址和大小传递给应该写入该数组的函数:
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
是一个编译时常量,这意味着该函数只能处理一个数组大小。其次,在应用下标之前必须取消对指针的引用,这会使代码变得混乱。处理数组时,指向数组的指针工作得更好使用多维数组的g。这个美妙的邪恶暗示怎么样
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);
...
}
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]);
...
}
#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; \
}
#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;
}
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 */
}
#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;
}