Как вернуть указатель на массив в c

Question

Я вызываю функцию getdata() ниже внутри main(). getdata() читает символы из uart и помещает их в массив. В конце функции он выдает массив над uart.

Вопрос в том, как я могу вернуть эту функцию для возврата данных? Я понимаю, что вы не можете возвращать массивы в c и что вы должны объявить функцию, возвращающую указатель.

Как я мог сделать это с помощью функции ниже, чтобы я мог записать данные в главном, а не делать это внутри getdata().

int main(void) 
{ 
    getdata(); 
} 

void getdata(void) 
{ 
    static uint8_t ndx; 
    char recChars[6]; 
    char retchar; 
    ndx = 0; 

    retchar = getch(); 
    recChars[ndx] = retchar; 
    ndx++; 

    if (retchar == '\r'){ 
     recChars[ndx] = '\n'; 
     ndx = 0; 
     uart_write(UART_D, (uint8_t *)recChars, sizeof(recChars)); 
    }    
} 

char getch(void) { 
uint8_t ch = 0; 
chuart_read(UART_D, &ch); 
return ((char) ch); 
} 

Answer 1

Вам нужно сделать recChars указатель и выделить динамическую память для его использования malloc() или семьи. Затем вы можете вернуть указатель на вызывающий и использовать его в вызывающем.

Что-то вроде

char * getdata()   //change return type 
{ 
    static uint8_t ndx; 
    char * recChars = NULL; // change to pointer 
    char retchar; 
    ndx = 0; 

    if ((recChars = malloc(6)) == NULL) return NULL; 

    retchar = getch(); 
    recChars[ndx] = retchar; 
    ndx++; 

    if (retchar == '\r'){ 
     recChars[ndx] = '\n'; 
     ndx = 0; 
     //uart_write(UART_D, (uint8_t *)recChars, sizeof(recChars)); 
    }  

    return recChars;  //finally return 
} 

Помните, что возвращаемый указатель должен быть free() -d в вызывающем, после использования закончится, чтобы избежать утечки памяти.

Answer 2

Вы должны написать функцию, которая возвращает указатель на char и использовать malloc для выделения памяти. Вы должны использовать таНос, поскольку массивы объявлены как этого

char v[11]; 

относитесь к автоматическому классу хранения, который означает, что они имеют блок сферы, они удаляются, как только ваши возвратов функции и они не инициализируются по умолчанию. Вместо динамической памяти можно получить доступ в любом месте вашей программы, если у вас есть указатель на этот блок памяти. Вы также не забыли освободить память, используя free(), чтобы избежать утечки памяти. Если вы вернете указатель на автоматический массив, вы, вероятно, получите SIGSEGV, потому что ваш указатель держит ячейку памяти, которая больше не существует. Таким образом, вы могли бы написать что-то вроде этого:

char *foo(void) 
{ 
    char *p = malloc(sizeof(type) * n); 
    return p; 
} 

В главном

int main(void) 
{ 
    char *pointer = foo(); 
    /*Do something*/ 
    free(pointer); 
    return EXIT_SUCCESS; 
} 

PS: Прошу прощения за мой английский

Answer 3

Я бы посоветовал вам объявить массив в функции main() сам передать укажите ссылку на функцию getdata, поэтому при обновлении getdata(), который будет отображаться в массиве в main().

Примечание: Кстати, почему вы используете sizeof (recChars), который даст 6, но вы обновляете только до 2 местоположений. Я включить это также в коде

int main(void) 
{ 
    char recChars[6]; 
    int Rxd_Len = 0; 

    Rxd_Len = getdata(&recChars); //Pass the address of array 
    uart_write(UART_D, (uint8_t *)recChars, Rxd_Len); 
} 

int getdata(char *ptr_recChars) 
{ 
    uint8_t ndx; // removed static since its not a required/mandatory 
    char retchar; 
    ndx = 0; 

    retchar = getch(); 

    *(ptr_recChars + ndx) = retchar; //Asign the value to the array address + offset 


    if (retchar == '\r'){ 
     ndx++; 
     *(ptr_recChars + ndx) = '\n'; 

    } 

    return ndx;   
} 

char getch(void) { 
uint8_t ch = 0; 
int ret; 
ret = uart_read(UART_D, &ch); 
return ((char) ch); 
} 

UPDATE:

Это нормально называть uart_write() в основной()? Да, вы можете это сделать, но так как uart_write() будет использовать длину для передачи, вам нужно отслеживать ее, используя другую переменную.

Кроме того, почему эта линия необходима? Что он делает *(ptr_recChars + ndx) = retchar;? ptr_recChars указатель, который указывает на массив recChars[6], поэтому с помощью этого указателя можно обновить массив recChars[6], даже если он объявлен в main(), *(ptr_recChars + ndx), здесь ndx является 0 так обновляется первый элемент массива, то после этого вам приращение ndx затем, используя переменный указатель, мы можем указать на новое обновленном место на *(ptr_recChars + ndx) (с ndx новым значением в настоящее время)

Кроме того, я должен & оператора в GetData (& recChars); Нет, имя массива само по себе является указателем, поэтому для recChars[6] simplay, дающий recChars, предоставит базовый адрес массива, а также примечание recChars и &recChars[0] означает то же самое. Так что если вы дадите &recChars, значит, recChars - это адрес, а затем добавление &recChars принимает адрес адреса, который даст вам недопустимое значение в вашем выражении.

Answer 4

Вы можете написать функцию, которая возвращает char *, и использовать malloc для создания некоторого хранилища для этой таблицы, как упомянуто выше, или вы можете просто объявить свой массив как статический и вернуть его. В более явном виде:

char * getdata (void) { static char retChar [6]; ... return retChar; }

Работы. Причина этого в том, что хранилище массивов зарезервировано в специальном сегменте.

версия с таНосом оставляет за собой хранилище для массива в куче, которая требует от вас, чтобы освободить его впоследствии:

символ * GetData (недействительный) { символа * retChar = (символ *) таНос (6) ; ... return retChar; }

основное() { char * ptr = getdata(); ... free (ptr); }

Наконец, единственным, что вы не можете сделать, это объявить массив и возвращает его как есть, без статической декларации и не таНоса ... Причина этого заключается в том, что ваш массив выделяется в вызове -stack, и поэтому потенциально теряется, когда вы возвращаете из getdata. Другими словами, никогда не делайте: char * getdata (void) { char retChar [6]; ... return retChar; }