[C] zwracanie struktury

Witam! Mam pewien problem ze zwróceniem struktury. Po kolei:
oto struktura:

typedef struct{                                                                 
    float **macierz;
    int lw;
    int lk;
}macierz_t;

oto funkcja:

macierz_t* dodaj_macierze(macierz_t *macierz1, macierz_t *macierz2)
{
    int i,j;
    macierz_t* macierz3;

    macierz3->lw=macierz1->lw;
    macierz3->lk=macierz1->lk;
    alokuj_tablice_macierzy(macierz3);
    
    if(macierz1->lw!=macierz2->lw || macierz1->lk!=macierz2->lk)                                                  
    {
        printf("Zle rozmiary macierzy\n");
        exit(EXIT_FAILURE);
    }                                                                           /*macierze muszą być takich samych rozmiarów*/
    else
    {
        for (i=0; i<macierz3->lw; i++)                                          /*kolejne wiersze*/
        {                                                 
            for (j=0; j<macierz3->lk; j++)                                      /*kolejne kolumny*/                                     
                macierz3->macierz[i][j]=macierz1->macierz[i][j]+macierz2->macierz[i][j];               /*oblicza sumę odpowiednich elementów*/
        }                                                                                      
    }
    return macierz3;  
        
}

i tak mam w mainie:

macierz_t macierz1, macierz2,*macierz3;

czytaj(&macierz1, argv[1]);

czytaj(&macierz2, argv[2]);

macierz3=dodaj_macierze(&macierz1,&macierz2);                                                       
wypisz_macierz(macierz3);
zwalniaj(macierz3);

program sypie się gdzieś w funkcji. macierz3 jest raczej dobrze liczona (wyprintfowana w funkcji jest taka jak oczekuję), błąd musi być gdzieś przy zwracaniu. pomoże ktoś?

po zadeklarowaniu macierz_t* macierz3; powinienes uzyc malloc zeby przydzielic miejsce na pola tej struktury

zrobiłem takie coś i działa. dzięki wielkie [browar]

macierz3=(macierz_t*)malloc(sizeof(macierz_t));

a ja radzę zrobić tak:

void dodaj_macierze(macierz_t *wynik, macierz_t *macierzA, macierz_t *macierzB)

W ten sposób nie jesteś zmuszony do manipulowania pamięcią.

to powinienem dążyć do jak najmniejszego manipulowania pamięcią, czy to jest już tylko kwestia wygody?

generalnie jak sie uzywa C to trzeba zakladac ze bedzie sie bezposrednio manipulowac pamiecią :P

PS. po kazdym mallocu powinienes sprawdzac czy nie zwrocil NULL'a (np. jak zabraknie pamieci)

tak, wiem ;-)

to jest kwestia wygody. Obie wersje mają swoje zalety i wady.
Osobiście to zrobiłbym to na zasadzie przeciążenia i utworzyłbym obie wersje, by stosować to co akurat jest wygodniejsze (efektywniejsze). Oczywiście wersja alokująca powinna wywoływać kod wersji niealkoholizującej pamięci, by nie pisać tego samego kodu 2 razy.

Czyli:

macierz_t* dodaj_macierze(macierz_t *macierz1, macierz_t *macierz2)
{
     assert(macierz1->lw == macierz2->lw);
     assert(macierz1->lk == macierz2->lk);

     macierz_t* wynik = utworzMacierz(macierz1->lw, macierz1->lk);
     assert(wynik); // względnie zastąpić asercję przez: if(wynik)
     dodaj_macierze(wynik, macierz1, macierz2); // wywołanie wersji bez operowania na stercie

     return wynik;
}

Dla jasności nazwałbym to jakoś inaczej, np: macierz_t * stworzSume(macierz_t *,macierz_t *).