Come restituire un array 2D a una funzione in C?

Question

Sono un programmatore Ruby che ha finito per sviluppare un codice generato per C. È come chiedere a una Limousine di trainare un camion degli anni '60. Comunque.

Ecco cosa ho pensato dovrebbe funzionare ma non funziona.

float[][] pixels() 
{ 
    float x[][]= { {1,1},{2,2} }; 
    return x 
} 

void drawLine(float x[][2]) 
{ 
    //drawing the line 
} 

//inside main 
drawLine(pixels()); 

ho sbattuto la testa sulla mia scrivania cercando di ottenere questo lavoro cosa. Per favore aiuto.

Answer 1

Grazie a tutti per le vostre risposte e in particolare per la spiegazione dettagliata della relazione tra puntatori e array.

ho incapsulati la matrice in una struttura

struct point_group1 { 
     float x[3]; 
     float y[3]; 
}; 

struct point_group1 pixels(){ 
    struct point_group1 temp; 

    temp.x[0] = 0.0; 
    temp.x[1] = 1.0; 
    temp.x[2] = -1.0; 

    temp.y[0] = 0.0; 
    temp.y[1] = 1.0; 
    temp.y[2] = 1.0; 

    return temp;  
} 



struct point_group1 points1 = pixels(); 
axPoly(points1.x, points1.y ,3, 0.0); 

Answer 2

Il modo più semplice è destinata probabilmente ad essere dichiara la matrice float in principale e avendo pixels basta riempirlo:

#define PIXEL_X_SIZE 2 
#define PIXEL_Y_SIZE 2 

int pixels(float x[][PIXEL_X_SIZE], int len) { 
    /* I don't know if you want the logic of this method to ever change, 
     but this will be roughly equivalent to what you do above */ 
    if (len < PIXEL_Y_SIZE) { 
     /* the length of the passed array is too small, abort */ 
     return -1; 
    } 

    x[0][0] = x[0][1] = 1; 
    x[1][0] = x[1][1] = 2; 
    return 0; 
} 

void drawLine(float x[][PIXEL_X_SIZE]) { 
    /* this will work fine */ 
} 

int main() { 
    float pixel_array[PIXEL_Y_SIZE][PIXEL_X_SIZE]; 
    pixels(pixel_array, PIXEL_Y_SIZE); 
    drawLine(pixel_array); 
} 

È anche possibile utilizzare malloc e free e memorizzare i pixel sul mucchio, ma se questo è tanto più grande sarà l'array di pixel, non c'è davvero bisogno e aggiunge solo ulteriore complessità per assicurarsi che la memoria venga sempre allocata e liberata correttamente.

Answer 3

Poverina. In C, i puntatori e gli array sono strettamente correlati. Inoltre, di solito è necessario passare la dimensione di un array come variabile separata. Diciamo Si inizia con:

#include <stdio.h> 

float** createArray(int m, int n) 
{ 
    float* values = calloc(m*n, sizeof(float)); 
    float** rows = malloc(n*sizeof(float*)); 
    for (int i=0; i<n; ++i) 
    { 
     rows[i] = values + i*m; 
    } 
    return rows; 
} 

void destroyArray(float** arr) 
{ 
    free(*arr); 
    free(arr); 
} 

void drawLine(const float** coords, int m, int n); 

int main(void) 
{ 
    float** arr = createArray(2,2); 
    arr[0][0] = 1; 
    arr[0][1] = 1; 
    arr[1][0] = 2; 
    arr[1][1] = 2; 
    drawLine(arr, 2, 2); 
    destroyArray(arr); 
} 

Answer 4

In C/C++, quando si passa un array a una funzione, decade ad essere un puntatore che punta al primo elemento della matrice. Quindi, nella funzione pixels(), si restituisce l'indirizzo di una variabile allocata nello stack. L'indirizzo della variabile di restituzione non è più valido perché al ritorno pixels(), la variabile allocata allo stack non rientra nell'ambito. Quindi, dovresti invece per una variabile la cui memoria è dinamica (cioè, usando malloc, calloc).

Quindi, per un array bidimensionale, è possibile utilizzare float** arrayVariable;. Inoltre, se si passa a una funzione, si dovrebbe essere cauti su quante righe ha & colonne.

int rows, columns; 

float** pixels() 
{ 
    // take input for rows, columns 
    // allocate memory from free store for the 2D array accordingly 
    // return the array 
} 

void drawLine(float** returnedArrayVariable) 
{ 
    //drawing the line 
} 

Dal momento che, matrice 2D è la gestione delle risorse è di per sé, dovrebbe restituire le risorse di nuovo al deposito gratuitamente utilizzando libera.

Answer 5

float (*pixels(void))[2] 
{ 
    static float x[2][2]= { {1,1},{2,2} }; 
    return x; 
} 

void drawLine(float (*x)[2]) 
{ 
    //drawing the line 
    //x[0][0]; 
} 

//inside main 
drawLine(pixels());