När man använder C språk, hur ska man skriva här ?
Deklarera en funktion som retunerar
en int array enligt följande exempel:

#include <studio.h>

/* Här kommer funktionsdeklaration som ska retunera en int array*/
int testarray[10](void);

int main(void)
{

/*kod som följer main*/

/* anrop till funktionen testarray */
test = testarray();

return 0;
}

/* Här kommer själva testarray */
int testarray[10](void)
{

kod som följer

return num([i]);
}

Tacksam på förslag hur man skriver detta.

Jag har väldigt svårt att se varför du vill göra något liknande. Returnera ett objekt som hanterar arrayer istället det är inte dyrt att skapa och gör att du slipper många problem.

Om du verkligen vill använda arrayer kommer du få problem med storleken, du kan inte specificera längden på den returnerade arrayen eftersom en array egentligen bara är en pekare.
Det går förvisso att göra en template som tar längden som parameter men då tycker jag att det är bättre att skapa en ordentlig arrayhanteringsklass istället.

En C/C++ funktion kan bara returnera ett värde (int, double, char, struct, pekare osv).

Det finns flera sätt att lösa det du vill göra:
1. Skicka in arrayen som skall fyllas i som argument
void testarray(int array[10]) {
array[0] = ...
}

2. Stoppa in arrayen i en struktur
struct minarray {
int array[10];
};

struct minarray testarray(void) {
struct minarray a;
a.array[0] = ...
return a;
}

3. använd en färdig arrayklass i c++
typedef boost::array<int, 10> minarray;
minarray testarray() {
minarray a;
a[0] = ...
return a;
}

Ett fjärde sätt är att använda pekare:
<code>
#include <iostream>
using namespace std;

int *testarray(void);

int main(void)
{
int *test = testarray();

for(int i=0; i<10; i++)
cout << test[i] << endl;

delete test;

system("pause");

return 0;
}

int *testarray(void)
{
int *arr = new int[10];

for(int i=0; i<10; i++)
arr[i] = i*i;

return arr;
}
</code>

Det här sättert är inte att föredra, dels pga minnet som allokeras i metoden men måste deallokeras utanför av den som anropar den. Det kommer bli minnesläcka för eller senare i alla projekt av någorlunda storlek. Ytterligare ett argument är att det inte är särskilt bra att anta att metoden returnerar en array med tio platser. Vad händer när det ändras?
Om man nu skyr objekt som pesten (vilket verkar lite konstigt om man ska utveckla i ett OOP-språk) bör man skicka in en förallokerad array som kan fyllas med data.

Jag skrev inte att det var något lämpligt sätt, utan ville bara visa på ett vanligt sätt att lösa problemet. Det kan fungera bra för små projekt, men är som du skriver olämpligt för större projekt.

Jag förstår, själv skrev jag bara att det inte var en bra idé att ta till sig som nybörjare. Jag tycker att det är dumt att vänja sig vid något som i långa loppet mest kommer ge problem.

Och att överhuvudtaget använda arrayer är i regel helt vansinnigt, såvida man inte kör C eller har enorma prestandakrav och är väldigt kunnig.

Använd istället vector (en av de "färdiga arrayklasserna" som Martin Adrian föreslog, fast en som finns i standarden), som ligger i biblioteket vector.

Alltså

#include <vector>

std::vector<int> fun();

int main()
{
...
}

std::vector<int> fun()
{
std::vector<int> v;

//gör nåt med vektorn

return v;
}

Om man dessutom har en funktion som bygger upp en stor array och bryr sig om prestanda, så skall man aldrig returnera en vector eftersom det innebär en <allokering av lokal array>-<allokering av ny array>-<kopiering>-<avallokering av gammal array>.

Man skall istället skicka in en referens till en vector som funktionen sedan kan fylla på.

#include <vector>

void fun(std::vector<int> &v);

int main()
{
std::vector<int> minVector;

fun(minVector);

...
}

void fun(std::vector<int> &v)
{
//gör nåt med vektorn v, t.ex. ändra storlek och fyll i värden.
}


/Andreas

Naturligtvis. Andreas har rätt, jag har fel.

(Fast även om prestandan påverkas mycket negativt är det inte säkert att det påverkar applikationen nämnvärt...)

Hur som helst; det viktiga är att man inte bör göra det med arrayer och pekare etc.

>Om man dessutom har en funktion som bygger upp en stor array och bryr sig om prestanda, så skall
>man aldrig returnera en vector eftersom det innebär en <allokering av lokal array>-<allokering av ny
>array>-<kopiering>-<avallokering av gammal array>.

En bra kompilator optimerar genom att skicka med var resultat skall sparas (Return Value Optimization=RVO) så resultatet blir detsamma som din omskrivning.