Anfängerfrage: Werte zwischen Member Funktionen übergeben

DerBert

ich habe in einer funktion eine doppelte for-schleife in der ich werte auslese. diese werte möchte benötige ich ebenfalls in einer weiteren funktion möchte die daten aber nicht ein zweitesmal auslesen lassen!

Firefighter

ein bisschen präziser müsstest du es uns schon erklären und/oder ein bisschen code zeigen

DerBert

void MyMemFunc::read(data* readdata)
{
....
...
	for(int i = 0; i < readdata>x ; i++)
	{
		for(int j = 0; j < readdata->y; j++)
		{
		value = ((unsigned short) readdata>box[(j)]);
...
..
}
}

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.

Hallo

Warum übergibst du value nicht einfach?

chrische

unskilled

//fkt:
std::vector <unsigned short> MyMemFunc::read(data* readdata)
{
    std::vector <unsigned short> R; //#include <vector>
    for(size_t i (0); i < readdata->x ; ++i)
    {
        for(size_t j (0); j < readdata->y; ++j)
        {
        R.push_back (reinterpret_cast <unsigned short> (readdata->box[j]));
        }
    }
    return R;
}

//main:
int main (/*blubb*/)
{
/*
data* readdata;
MyMemFunc MemFuncClass;
*/
std::vector <unsigned short> Values (MemFuncClass->read(readdata));
MemFuncClass->NextFkt (Values);
/*
...
*/
}

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;
}