ich benötige jeden wert von value in einer anderen funktion.
soll ich value in einem weiteren array ablegen oder nochmals auf das array zugreifen?
die funktion in der die value werte ein weiteresmal gebraucht werden ist eine funktion die ausserdem opengl befehle beinhalten soll die in der glut paint func aufgerufen werden sollen.

Warum übergibst du value nicht einfach?

chrische

edits: alternativ könntest du auch nur die referenz auf den vector übergeben - aber da müsstest du dich dann jedes ma um das delete kümmern...
also so was:

std::vector <unsigned short>& MyMemFunc::read(data* readdata)
// std::vector <...> *R = new std::vector <....>;
// return *R;

int main (/*bla*/)
{
/*...*/
std::vector <unsigned short> Values (MemFuncClass->read(readdata));
MemFuncClass->NextFkt (Values);
//MyMemFunc::NextFkt (std::vector <...> &Values); //evtl noch nen const davor - musst du wissen ^^
delete &Values;
/*...*/
}

noch ein letztes edit:
weiß ja nicht, warum du 2 for schleifen hast (weil ich das i nirgendwo seh ^^), aber du könntest dir auch überlegen, nen 3d-array zu machen...

also:

typedef std::vector <unsigned short> row;
typedef std::vector <row> myshortarray;

//fkt:
myshortarray MyMemFunc::read(data* readdata)
{
    myshortarray RETURN;
    for(size_t i (0); i < readdata->x ; ++i)
    {
        row ROW;
        for(size_t j (0); j < readdata->y; ++j)
        {
        ROW.push_back (reinterpret_cast <unsigned short> (readdata->box[j]));
        }
        RETURN.push_back (ROW);
    }
    return RETURN;
}

da haste dann so nen array:

0   1   2   3   ...   j
0
1
2
...
i

das array kannste dann entweder mit iteratoren durchgehen oder so, wie du das gewöhnt bist mit [...] dahinter... wobei iteratoren eleganter und sicherer sind...

würde so gehen:

std::vector <size_t> a;
for (size_t i (0); i < 10; ++i)
   a.push_back (i);
const std::vector <size_t>::const_iterator ende (a.end ());
for (std::vector <size_t>::const_iterator i (a.begin ()); i != ende; ++i) //hier auf jeden fall ++i anstatt i++ nehmen...
{
std::cout << i << std::endl;
}

bei so was mach ich mir aber meist noch typedefs von const_iterator, weil das sonst immer so ewig lange zeilen sind ^^
und wenn du den Inhalt des Arrays verändern willst:

for (std::vector <size_t>::iterator i (a.begin ()); i != ende; ++i) //OHNE const halt...
{
i *= 123456;
}