使用C返回数组

Question

使用C返回数组我对C比较陌生，我需要一些处理数组的方法的帮助。来自Java编程，我习惯于说int [] method()以返回数组。但是，我发现在使用C时，在返回数组时必须使用指针。作为一个新的程序员，我真的一点也不明白这一点，即使我已经浏览了许多论坛。基本上，我试图编写一个在C中返回char数组的方法。我将为该方法提供一个数组(让我们将其称为返回数组)。它将从前一个数组创建一个新数组，并返回指向该数组的指针。我只需要一些帮助，如何开始这一点，以及如何读取指针，一旦它被发送出数组。任何解释这一点的帮助都是非常感谢的。阵列返回函数的编码格式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编译器目前还没有工作，但是我想弄清楚这一点。

Answer 1

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 a[6]..在……里面sizeof str，因为数组表达式是sizeof运算符，它没有转换为指针类型，因此您可以获得数组(6)中的字节数。

如果你真的有兴趣，你可以读丹尼斯·里奇的C语言的发展来了解这种治疗的来源。

结果是函数不能返回数组类型，这很好，因为数组表达式也不能作为分配的目标。

最安全的方法是调用方定义数组，并将其地址和大小传递给应该写入的函数：

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有数组类型)。

你，你们能，会，可以声明指向N元素数组的指针。T做一些类似的事情：

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要成为编译时常量，意味着该函数只能使用一个数组大小。其次，在应用下标之前，必须取消指针的引用，这会使代码混乱。当您处理多维数组时，指向数组的指针工作得更好。

Answer 2

这个美妙的邪恶实现如何？

数组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;    \}

主.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;}