C functie return array (2d)

[vinietje]

Hoi,

ZIt al paar uur te hobby'en om iets aan de gang te krijgen.

Heb een functie in elkaar gezet, zie onderstaande code (pseudo)

code:

#include <stdio.h>

int functie(void)

maint()
{
int 2darray[12][6];

2darray = functie();

return 0;
}

int functie(void)y
{
int temparry[12][6];

for (x=0; ......
{

open bestand. lees alles in array etc. etc.

return array;

}

Nou is bovenstaande een stukje pseudo code maar het id is als volgt.
Door een functie wordt een tekst file ingelezen. (dit werkt).
Maar nu wil ik via return een 2 demensionaal array terug sturen aan main.
dit werkt dus niet ofzo. krijg hele tijd fouten.

vraag: is dit wel mogelijk: een array via return terug sturen in een array in de main?

bvd.

Vincent

Gelieve je code in 't vervolg tussen code-tags te plaatsen, dat leest stukken beter

[ Voor 8% gewijzigd door whoami op 11-11-2005 10:33 ]

[Reptile209]

Ja, dat is mogelijk. Maar in C gaat dat via een pointer (google that ) en dat is iets dat je jezelf goed eigen moet maken om effectief in C te kunnen werken. Je functiedefinitie wordt dan iets als:

code:

int **functie(void)

Edit: Eh, ja, wat Daos en Voutloos hieronder zeggen.
Als je je array pas in de functie declareert, mag je hem daarbuiten niet meer gebruiken. Daar krijg je hele vieze en vervelende bugs van. Declareer een array in main (of in de aanroepende functie), geef een pointer naar de array aan je functie, doe je ding en dan hoef je ook niks meer terug te geven (behalve bijvoorbeeld een foutcode) want de array is al bekend bij de aanroepende functie.

[ Voor 50% gewijzigd door Reptile209 op 10-11-2005 21:34 ]

[Daos]

nee, dat gaat niet werken. Je moet dat array meegeven als argument aan je functie.

[edit]
Zoiets dus:

C:

#include <stdio.h>
void functie(int[][]);

int main() {
  int tweedarray[12][6];

  functie(tweedarray);

  return 0;
}

void functie(int temparray[][6]) {
  int x;
  for (x=0; ...... ) {
  }

  open bestand. lees alles in array etc. etc.
}

Meer uitleg hierover vind je in elk boek over C(++).

offtopic:
Gebruik voortaan codetags in je post.

[ Voor 75% gewijzigd door Daos op 10-11-2005 21:44 ]

[Voutloos]

Daos schreef op donderdag 10 november 2005 @ 21:30:
nee, dat gaat niet werken. Je moet de pointer naardat array meegeven als argument aan je functie.

[MisterData]

Als je C++ zou kunnen gebruiken kun je misschien beter een std::vector< std::string > returnen, dat is een stuk makkelijker en veiliger

[vinietje]

Helaas, kan alleen c gebruiken.

maar het is dus niet mogelijk een lokaal gedefinierd array via return in een main array over te zetten?

[Reptile209]

vinietje schreef op donderdag 10 november 2005 @ 21:34:
Helaas, kan alleen c gebruiken.

maar het is dus niet mogelijk een lokaal gedefinierd array via return in een main array over te zetten?

Dat kan wel (hint: new), maar het is niet echt netjes en tamelijk foutgevoelig, zeker bij beginnende programmeurs (zoals ik gok dat jij bent) . Het is veel makkelijker om dat buiten je functie te houden.

[Soultaker]

Ten eerste moet je onderscheid maken tussen een jagged array en een 'echte' twee-dimensionale array. De eerste is een array van pointers naar arrays en heeft bijvoorbeeld type int**; de andere is een echte array van arrays en heeft bijvoorbeeld type int(*)[6].

Een jagged array ziet er in het geheugen zo uit:

code:

+---+     +---+---+---+
| 0 | ==> | a | b | c |     
+---+     +---+---+---+     +---+---+---+
| 1 | ====================> | d | e | f |
+---+     +---+---+---+     +---+---+---+
| 2 | ==> | g | h | i |
~~~~~     +---+---+---+
 etc.

Elke rij (of kolom) uit je matrix zit dus in een opvolgend stuk geheugen. Dat betekent dat niet elke rij even lang hoeft te zijn en je hoeft bij het compileren nog niet te weten welke dimensies je array krijgt.

Een 'echte' 2D array ziet er zo uit:

code:

+---+---+---++---+---+---++---+---+~
| a | b | c || d | e | f || g | h |~ etc.
+---+---+---++---+---+---++---+---+~

Daarbij zitten dus alle waarden in het geheugen en moet je wel bij het compileren alle dimensies (behalve één) specificeren.

In beide gevallen kun je een array niet direct retourneren omdat het geen volwaardig datatype is (een array vervalt naar een pointer als je 'm wil retourneren). Als de array een vaste afmeting heeft, is een mogelijke oplossing om een struct te definiëren met daarin de array. Die kun je wel retourneren.

Een andere veelgebruikte methode is dat de caller de afmetingen en een pointer naar de array meegeeft en dat jouw functie 'm alleen maar invult.

[.oisyn]

vinietje schreef op donderdag 10 november 2005 @ 21:34:
Helaas, kan alleen c gebruiken.

maar het is dus niet mogelijk een lokaal gedefinierd array via return in een main array over te zetten?

Nee, hij is immers lokaal en bestaat daarna niet meer.

Reptile209 schreef op donderdag 10 november 2005 @ 21:35:
[...]

Dat kan wel (hint: new)

(hint: je bedoelt malloc )

[ Voor 81% gewijzigd door .oisyn op 10-11-2005 21:37 ]

[Reptile209]

offtopic:
* Reptile209 zegt niks meer en zwengelt voor het eerst in jaaaaren weer eens een C-compiler aan voordat hij nog wat zegt

[Voutloos]

.oisyn schreef op donderdag 10 november 2005 @ 21:36:
(hint: je bedoelt malloc )

Als we dan toch zoektermen strooien, wijs ik TS er bij deze maar op dat malloc() gepaard gaat met free().

[NMe]

Bij arrays vind ik het persoonlijk altijd fijner om calloc te gebruiken in plaats van malloc. Ten eerste omdat die daar eigenlijk voor gemaakt is, en ten tweede omdat calloc meteen elk element initialiseert op 0.

Maar is dat initialiseren niet nodig, dan zou je in principe wegens snelheidsoverwegingen beter malloc kunnen gebruiken.

[epic007]

In C++ lukt het wel via een "vieze" cast

C++:

int size = 12*6*sizeof(int);
char * pointer = new char[size];
int (&array2d)[12][6] = *(int(*)[12][6])pointer;
// pointer en array2d verwijzen nu naar hetzelfde stuk geheugen

[.oisyn]

In C++ heb je die cast niet nodig

C++:

int (*array)[6] = new int[12][6];

Bovendien gaat jouw code gruwelijk fout als je een multidimensional array wil maken van custom types met een constructor, omdat die dan niet aangeroepen worden en je 'm bovendien niet meer kunt delete[]'en (alleen door terug te casten naar een char*, en dan runnen er weer geen destructors)

[ Voor 71% gewijzigd door .oisyn op 11-11-2005 11:33 ]

[Soultaker]

@.oisyn: als je die syntax niet kent (de syntax voor multi-dimensionale arrays en functie-pointers vinden veel mensen - terecht - moeilijk) kun je altijd nog 'new T[12*6]' doen en dat casten. Dan worden alle constructors netjes aangeroepen en kun je (na terugkasten naar T*) ook met delete[] alles netjes opruimen.

Voor anderen: kijk nog even naar mijn eerdere post over de geheugenlay-out van multidimensionale arrays. Die komt overeen met die van enkele arrays en de casts zijn dus alleen nodig zodat de compiler hetzelfde geheugen anders interpreteert.

[.oisyn]

Soultaker schreef op vrijdag 11 november 2005 @ 16:39:
@.oisyn: als je die syntax niet kent (de syntax voor multi-dimensionale arrays en functie-pointers vinden veel mensen - terecht - moeilijk) kun je altijd nog 'new T[12*6]' doen en dat casten. Dan worden alle constructors netjes aangeroepen en kun je (na terugkasten naar T*) ook met delete[] alles netjes opruimen.

Mijn punt was echter dat epic007 die syntax klaarblijkelijk wél kent, maar het alsnog met een omweg doet die niet safe is. En ook jouw manier hoeft niet safe te zijn, wie zegt dat een implementatie het aantal objecten in een multidimensionale array op dezelfde manier in het geheugen zet als bij een enkele array? Wellicht zet hij elke dimensie wel apart in het geheugen. Ook van jouw oplossing heb je dus geen keiharde garantie dat het werkt.

[MSalters]

Nou is dat laatste geen probleem: een array, hoeveel dimensies die ook heeft, is 1 object, en dus een enkel blok geheugen. Elke dimensie apart mag alleen bij arrays-van-arrays (de "jagged" versies), en dat zijn geen multidimensionale arrays.

[Soultaker]

.oisyn schreef op vrijdag 11 november 2005 @ 17:00:
En ook jouw manier hoeft niet safe te zijn, wie zegt dat een implementatie het aantal objecten in een multidimensionale array op dezelfde manier in het geheugen zet als bij een enkele array?

Voor zover ik weet is de compiler dat nu juist wel verplicht. (Als die layout niet vaststond zou ik er niet over beginnen in mijn uitleg eerder.) Gaat dus wel goed; maar wijs me gerust op de passage in de standaard die het tegendeel beweert.

[.oisyn]

Ik bedoel niet de layout van de items in de array, maar het getalletje dat aangeeft hoeveel items er in de array staan (welke bij destruction weer wordt gebruikt). Ook dat staat meestal in het stuk geheugen, en dat hoeft volgens mij niet per se hetzelfde te zijn voor enkele en multidimensionale arrays

[ Voor 8% gewijzigd door .oisyn op 12-11-2005 16:37 ]

[Soultaker]

Ja natuurlijk, maar dat maakt niet uit als je 'm maar weer terugcast voordat je er delete[] op uitvoert. (Ik neem aan dat je bedoelt dat die i.h.a. niet veilig is: delete((B*)(new A))). Als je 'm hebt gealloceerd als ééndimensionale array, dan kun je 'm ook vrijgeven als ééndimensionale array.

In de praktijk denk ik trouwens dat de memory allocator geen onderscheid maakt tussen ééndimensionale en meerdimensionale arrays, maar goed, het gaat om het principe. Verder mag de memory allocator afaik helemaal zelf weten waar 'ie z'n bookkeeping doet, dus aannemen dat er getalletjes in je blok geheugen komen is natuurlijk ook niet de bedoeling.

[ Voor 65% gewijzigd door Soultaker op 12-11-2005 16:58 ]

[.oisyn]

Soultaker schreef op zaterdag 12 november 2005 @ 16:56:
Ja natuurlijk, maar dat maakt niet uit als je 'm maar weer terugcast voordat je er delete[] op uitvoert. (Ik neem aan dat je bedoelt dat die i.h.a. niet veilig is: delete((B*)(new A))). Als je 'm hebt gealloceerd als ééndimensionale array, dan kun je 'm ook vrijgeven als ééndimensionale array.

Daar heb je idd gelijk in.

Verder mag de memory allocator afaik helemaal zelf weten waar 'ie z'n bookkeeping doet, dus aannemen dat er getalletjes in je blok geheugen komen is natuurlijk ook niet de bedoeling.

Ik zei ook "meestal" . Hij kan natuurlijk net zo goed ergens een std::map<void*, size_t> oid bijhouden, mijn punt was meer dat een implementatie ervoor kon kiezen om dat verschillend te doen voor enkele en meerdimensionale arrays. Waarom moet je me niet vragen, maar zoals je zei, het gaat om het principe