Programozás segítség

Ügyesen:) Azért ez elég alapfeladat.

Újabb, "hihetetlenül nehéz kötelező proramot kell készíteni" tárgyú téma!
Hogy segítsek: egy jó C könyv elovasása, megértése és a google a baarátod:)

/* main.c */

#include "my_solutions.h"

int main()
{
double* myArray = readArray();
printArray(myArray);
}

/*
neked már csak a my_solutions.{h, c} fájlokat kell megírni.
*/
----
Hülye pelikán

Troll on

valós típusú adatokat tartalmazó Ez mi? A következő feladatban valótlan típusú adatokkal kell dolgozni? A feladat kirója kicsit jobban is megerőltethette volna magát...

/Troll off

a kifejezés, amit kerestél, az "elkelne egy kis segítség"

na de egyszerre csak egy nyelvet, még a végén összezavarodsz :3

Én ezt úgy csinálnám, hogy az első függvénybe teszek egy for ciklust(aminek 'i' a változója), 0-tól 9-ig számolva, ezen belül egy másik for ciklust(aminek 'j' a változója), szintén 0-tól 9-ig. A belsejében bekérek egy karaktersorozatot billentyűzetről, ellenőrzöm, hogy valós szám-e, majd beleteszem a tömb (i,j)-edik "fiókjába".

A második függvény belülről ugyanez, kivéve, hogy ott kiíratás történik. A belső ciklusban minden egyes kiírt érték után egy \t-t írnék, a külső ciklusban a belső for után pedig egy \n-t. Így lesz táblázatos.

A main()-ben meg meghívnám egymás után a két függvényt.

Remélem, ez megfelelő válasz volt a "Ti ezt hogyan csinálnátok?" kérdésre. Konkrét megoldásért úgy gondolom más fórumon kell kérdezősködnöd, vagy egy kisebb összeget felajánlani(nem nekem, én nem vagyok C guru) :)

attol fugg honnan kell beolvasni :)

fopen/fread esetleg open/read (talan az elobbivel egyszerubb, de mindenesetre hordozhatobb)

amugy meg scanf/printf fuggvenyek, esetleg strod scanf helyett, valamint malloc memoriafoglalashoz, arra vigyazz, hogy tobbdimenzios tombot dimenzionkent kell mallocolni (kiveve, ha utana nem tombkent hasznalod, hanem pointer artimetikazol, de szerintem nem fogsz kezdokent).

--
NetBSD - Simplicity is prerequisite for reliability

typedef struct{
          int number_of_rows;
          int number_of_columns;
          int alloc_state=0;
          double **elemek;
} matrix;

void matrix_inicializalas(const int rows, const int colums, matrix *matrica){
          matrica->number_of_rows = rows;
          matrica->number_of_colums = columns;
          matrica -> elemek = (double **) malloc(rows *sizeof(double*));
          for(int i=0; i< rows; i++) matrica->elemek[i] = (double *)malloc(columns*sizeof(double));
          matrica->alloc_state=1;
}

void matrix_felszabaditas(matrix *matrica){
         for(int i=0; i < matrica->nrows; i++) free(matrix->elemek[i]);
         free(matrix->elemek);
         matric->alloc_state=0;
}

main(){
      matrix alma;
      const int en=10;
      matrix_inicializalas(10,10,alma);
      printf("Matrix beolvasasa, johetnek az elemek: ");
      for(int i=0; i < alma->number_of_rows; i++) for (int j=0; j<alma->number_of_columns; j++) scanf("%lf", &alma->elemek[i][j]);
 
      printf("A matrix elemei:\n");
      for(int i=0; i<alma->number_of_rows; i++){
            for (int j=0; j <alma->number_of_columns; j++) printf("%lf\t", alma[i][j]);
            printf("\n");
      }
      matrix_felszabaditas(alma);
}

Nem próbáltam ki, kisebb hibák lehetnek benne. A lényeg, hogy próbáltam a mátrixnak létrehozni egy típust, amihez nem kell külön megadni a méretet. Előnye, hogy nem lehet eltéveszteni (melyik mátrix sorainak a számáról is van szó?) és emiatt segfaultolni, vagy memóriaszivárgást okozni.
Ha C++-ban írnád, akkor az egész lefoglalás mehetne a konstruktorba, a felszabadítás a destruktorba, és akkor a mátrix létrehozásakor már automatikusan le is foglalnád neki a tárterületet, és amikor a mátrix pusztul (pl. véget ér a hatásköre), akkor felszabadul a memória.
Ha komolyabb számoláshoz akarnád használni, akkor még persze hibakezeléssel kellene ellátni: a matrix_inicializalas()-ban, ha nem sikerül a lefoglalás (pl. nincs annyi memória), akkor amit már addig lefoglalt, azt fel kellene szabadítani, és az alloc_state-et 0-ra állítani; a mátrix használatakor pedig meg kellene nézni, hogy az alloc_state 1-e.

szerencsere az ilyen kerdeseket stackoverflow-n 5 perc alatt bezarjak.

Két sörért/Milka csokiért/usw.

Házit nem illik sem megkérdezni, sem pedig megoldani másnak errefelé...

Szóval
1.) be kell olvasni egy 10x10-es tömb elemeit.
2.) egy másik az elemeket kiírja táblázatos formában.

Minek foglaljak dinamikus memóriát? Nem kell tárolni csak beolvasni. :)
Nem volt feltétel, hogy egész program legyen.

Ha már segítség kell, akkor adj hozzá saját dolgot és legalább olvasd el, mert ez a feladat értelmetlen.

A valós számok szövegként vagy bináris formában vannak?

Az a baj, hogy nincs specifikálva, mit ért a kitűző az alatt, hogy "A dinamikusan foglalt."

Fentebb többféle megoldás van erre, egybe foglalni egy malloc-cal egy 10x10-es tömböt, 10 egydimenziós tömböt foglalni és azt összefogni, ... Melyikre gondolhatott a kitűző?

Nem ezen a kezdő C-tanuló szinten válik fontossá, de nem bírom megállni, hogy meg ne jegyezzem: komoly programozóktól is láttam utóbbi megoldást, tehát 2D tömböt soronkénti malloc-cal foglalni és egy mutatótömböt csinálni neki fejléccel, *és ez egy nagyon rossz megoldás!*

Logikailag rendben van a soronkénti malloc, de úgy szétfragmentálja a memóriát meg sok egyéb bajt okoz, hogy a program bizonyos tömbméretek esetén akár 2-3-szorosan is belassulhat (ha sok tömbelem olvasás/írás mellett nem túl sok a számolási művelet). Ezt gyakorlati példákban is láttam. Persze, a kérdésben szereplő 10x10-es egyszerű feladatban ez nem számít, de jó, ha a tanulás elején már jó reflexek rögzülnek.

Alig bonyolultabb ennél az, amikor az ember a 10x10=100 float-nak egyetlen malloc-cal foglal helyet és e terület megfelelő helyeire irányítja a fejléc pontereket. (No persze, ha fordítási időben tudjuk a méretet, akkor akár eleve 10x10-es tömböt is foglalhatunk egy malloc-cal.)

Szerintem igencsak kerülendő a ciklus belsejéből hívott malloc.

ez az orszag tenyleg az okostojasok orszaga csesszetek meg!