Zwracanie tablicy przy użyciu języka C

Jestem stosunkowo nowy w C i potrzebuję pomocy w metodach radzenia sobie z tablicami. Pochodząc z programowania w Javie, jestem przyzwyczajony do mówienia int [] method()w celu zwrócenia tablicy. Jednak odkryłem, że w C musisz używać wskaźników do tablic, kiedy je zwracasz. Będąc nowym programistą, naprawdę w ogóle tego nie rozumiem, nawet z wieloma forami, które przeglądałem.

Zasadniczo próbuję napisać metodę, która zwraca tablicę char w C. Dostarczę metodę (nazwijmy ją returnArray) z tablicą. Utworzy nową tablicę z poprzedniej tablicy i zwróci do niej wskaźnik. Potrzebuję tylko pomocy, jak to rozpocząć i jak odczytać wskaźnik po wysłaniu go z tablicy. Każda pomoc w wyjaśnieniu tego jest mile widziana.

Proponowany format kodu dla funkcji zwracającej tablicę

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?
} 

Wzywający funkcji

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?
}

Nie testowałem tego jeszcze, ponieważ mój kompilator C w tej chwili nie działa, ale chciałbym to rozgryźć

Nie możesz zwracać tablic z funkcji w C. Nie możesz (nie powinieneś) tego robić:

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 jest tworzony z automatycznym czasem przechowywania i odniesienia do niego staną się nieważne, gdy opuści swój zakres deklarowania, tj. gdy funkcja powróci.

Będziesz musiał dynamicznie przydzielać pamięć wewnątrz funkcji lub wypełnić wstępnie przydzielony bufor dostarczony przez wywołującego.

Opcja 1:

dynamicznie alokować pamięć wewnątrz funkcji (wywołujący odpowiedzialny za zwalnianie 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;
}

Nazwij to tak:

int main() {
    char *p = foo(10);
    if(p) {
        // do stuff with p
        free(p);
    }

    return 0;
}

Opcja 2:

wypełnij wstępnie przydzielony bufor dostarczony przez dzwoniącego (dzwoniący przydziela bufi przekazuje do funkcji)

void foo(char *buf, int count) {
    for(int i = 0; i < count; ++i)
        buf[i] = i;
}

I nazwij to tak:

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)
}

Sposób traktowania tablic w języku C bardzo różni się od sposobu traktowania w Javie i będziesz musiał odpowiednio dostosować swoje myślenie. Tablice w języku C nie są obiektami pierwszej klasy (to znaczy, że wyrażenie tablicowe nie zachowuje swojej „macierzy” w większości kontekstów). W języku C wyrażenie typu „tablica elementów N T” zostanie niejawnie przekonwertowane („rozpad”) na wyrażenie typu „wskaźnik do T”, z wyjątkiem sytuacji, gdy wyrażenie tablicowe jest operandem sizeofjednoargumentowym lub& operatorów lub, lub jeśli wyrażenie tablicowe to literał łańcuchowy używany do inicjalizacji innej tablicy w deklaracji.

Oznacza to między innymi, że nie można przekazać wyrażenia tablicowego do funkcji i odebrać je jako typ tablicowy ; funkcja faktycznie otrzymuje typ wskaźnika:

void foo(char *a, size_t asize)
{
  // do something with a
}

int bar(void)
{
  char str[6] = "Hello";
  foo(str, sizeof str);
}

W wywołaniu do foowyrażenie strjest konwertowane z typu char [6]na char *, dlatego zamiast parametru foodeklarowany jest pierwszy parametr . W , ponieważ wyrażenie tablicowe jest operandem operatora, nie jest konwertowane na typ wskaźnikowy, więc otrzymujesz liczbę bajtów w tablicy (6). char *achar a[6]sizeof strsizeof

Jeśli jesteś naprawdę zainteresowany, możesz przeczytać książkę Dennisa Ritchiego The Development of the C Language, aby zrozumieć, skąd pochodzi ta terapia.

W rezultacie funkcje nie mogą zwracać typów tablicowych, co jest w porządku, ponieważ wyrażenia tablicowe również nie mogą być celem przypisania.

Najbezpieczniejszą metodą jest zdefiniowanie przez wywołującego tablicy i przekazanie jej adresu i rozmiaru do funkcji, która ma do niej pisać:

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

Inną metodą jest dynamiczne przydzielanie tablicy przez funkcję i zwracanie wskaźnika i rozmiaru:

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

W tym przypadku wywołujący jest odpowiedzialny za zwolnienie tablicy za pomocą freefunkcji bibliotecznej.

Zauważ, że dstw powyższym kodzie jest prosty wskaźnik do char, a nie wskaźnik do tablicy char. Wskaźnik C i semantyka tablicy są takie, że można zastosować operator indeksu dolnego []do wyrażenia typu tablicowego lub typu wskaźnika; oba src[i]i dst[i]uzyskają dostęp do i'-tego elementu tablicy (nawet jeśli srcma tylko typ tablicy).

Państwo może zadeklarować wskaźnik do tablicy N-pierwiastkowej Ti zrobić coś podobnego:

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]);
  ...
}

Kilka wad z powyższym. Po pierwsze, starsze wersje języka C oczekują, SOME_SIZEże będzie to stała czasu kompilacji, co oznacza, że ​​funkcja będzie działać zawsze tylko z jednym rozmiarem tablicy. Po drugie, przed zastosowaniem indeksu dolnego należy usunąć odwołanie ze wskaźnika, który zaśmieca kod. Wskaźniki do tablic działają lepiej, gdy masz do czynienia z tablicami wielowymiarowymi.

Nie twierdzę, że jest to najlepsze lub preferowane rozwiązanie danego problemu. Warto jednak pamiętać, że funkcje mogą zwracać struktury. Chociaż funkcje nie mogą zwracać tablic, tablice mogą być opakowane w struktury, a funkcja może zwrócić strukturę, przenosząc w ten sposób tablicę. Działa to w przypadku tablic o stałej długości.

    #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;
    }

Zapraszam do komentowania mocnych i słabych stron tej techniki. Nie pofatygowałem się, żeby to zrobić.

A co z tą cudownie złą implementacją?

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

W twoim przypadku tworzysz tablicę na stosie i gdy opuścisz zakres funkcji, tablica zostanie cofnięta. Zamiast tego utwórz tablicę alokowaną dynamicznie i zwróć do niej wskaźnik.

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);

}

Możesz to zrobić używając pamięci sterty (poprzez wywołanie malloc () ), tak jak inne podane tutaj odpowiedzi, ale zawsze musisz zarządzać pamięcią (użyj funkcji free () za każdym razem, gdy wywołujesz swoją funkcję). Możesz to również zrobić za pomocą tablicy statycznej:

char* returnArrayPointer() 
{
static char array[SIZE];

// do something in your array here

return array; 
}

Możesz go używać bez martwienia się o zarządzanie pamięcią.

int main() 
{
char* myArray = returnArrayPointer();
/* use your array here */
/* don't worry to free memory here */
}

W tym przykładzie należy użyć słowa kluczowego static w definicji tablicy, aby ustawić okres istnienia tablicy na długość aplikacji, aby nie został zniszczony po instrukcji return. Oczywiście w ten sposób zajmujesz SIZE bajtów w swojej pamięci przez cały okres użytkowania aplikacji, więc odpowiednio ją dopasuj!

Twoja metoda zwróci lokalną zmienną stosu, która zakończy się poważnym niepowodzeniem. Aby zwrócić tablicę, utwórz tablicę poza funkcją, przekaż ją przez adres do funkcji, a następnie zmodyfikuj ją lub utwórz tablicę na stercie i zwróć tę zmienną. Oba będą działać, ale pierwsza nie wymaga żadnej dynamicznej alokacji pamięci, aby działała poprawnie.

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);
}

Możesz użyć takiego kodu:

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

Kiedy to zrobisz, pamięć powinna zostać później zwolniona, przekazując adres do zwolnienia.

Istnieją inne opcje. Procedura może zwrócić wskaźnik do tablicy (lub części tablicy), która jest częścią jakiejś istniejącej struktury. Obiekt wywołujący może przekazać tablicę, a procedura po prostu zapisuje do tablicy, zamiast przydzielać miejsce na nową tablicę.