Předávání (sdílení) pole struktur – C / C++ – Fórum – Programujte.com

 Zdravím, už nějakej čas nad tím koumám a nějak se nemůžu hnout z místa. Potřeboval bych mít v rámci programu jedno pole struktur, který budu ve funkci dle potřeby dynamicky zvětšovat a jakmile se vrátím do mainu, budu mít přístup ke všem jeho prvkům. Po vykonání určitý části ho pak chci zase pomocí ukazatele poslat jiné funkci. Tady je jednoduchá ukázka jak by to mělo vypadat. 

Nastává několik otázek:
1) můžu pole alokovat pomocí new() ve funkci a zrušit ho až ke konci mainu?
2) jakým způsobem bych měl potom v mainu přistupovat k těm prvkům? ( TResults.m_A?)

#include <cstdlib>
#include <cstdio>
#include <iostream>
using namespace std;



typedef struct TResults
 {
   int             m_A;
   int             m_B;
 } TRESULTS;
 
 
 void pokus(TRESULTS * res,int resL) {
 
     int agent=2;
     int mLen=10;
     
         res = new TRESULTS[resL+1];
         
         res[resL] . m_A = agent;
         res[resL] . m_B = mLen;

         resL++;

 }
 

int main(int argc, char** argv) {
 
    TRESULTS * res;
    int resL=0;
    
        pokus(res,resL);
      
    delete [] res;
    return 0;
}

Budu vděčný za jakoukoli radu! :-) 

#include <cstdlib>
#include <cstdio>
#include <iostream>
using namespace std;


//v c++ netreba vytvarat strukturu cez typedef
struct TResults {		
   int             m_A;
   int             m_B;
};

//kvoly prehladnosti
typedef TResults* TResults_ptr;	
 
 
 //referencie ti umoznia jednoducho menit premenne mimo funkcie 
 //(mohol by si pouzit aj viacnasobne pointre, ale bolo by to neprehladne)
 void pokus(TResults_ptr &res, int &resL) {	
     int agent=2;
     int mLen=10;
     
     //najprv musis prekopirovat stare pole do noveho a az potom inicializovat novy prvok
     TResults *new_res = new TResults[resL+1];
	 for(int i = 0; i < resL; ++i){
		 new_res[i] = res[i];
	 }
	 delete [] res;		//zmazanie stareho pola
	 
	 res = new_res;		
	 
	 res[resL].m_A = agent;
	 res[resL].m_B = mLen;

	 resL++;

 }
 

int main(int argc, char** argv) {
 
    TResults* res;
    int resL=0;
    
    pokus(res,resL);
    pokus(res,resL);
    pokus(res,resL);
    pokus(res,resL);
    
    for(int i = 0; i < resL; ++i)cout << res[i].m_A << " : " << res[i].m_B << endl;
      
    delete [] res;
    return 0;
}

Na tuto ulohu by bol lepsi zretazeny zoznam miesto pola. Pomocou stl to mozes mat na par riadkov:

#include <vector>
#include <list>#include <iostream>
using namespace std;

struct TResults {		
   int             m_A;
   int             m_B;
   TResults(int A = 2, int B = 10):m_A(A), m_B(B){}
};

int main(int argc, char** argv) {
	vector<TResults> res;		//alebo list<TResults>
	
	res.push_back(TResults());
	res.push_back(TResults());
	res.push_back(TResults());
	res.push_back(TResults());

    for(TResults &x : res)cout << x.m_A << " : " << x.m_B << endl;
    
    return 0;
}

Dovolil bych si přidat lepší a i jednodušší řešení =)

#include <iostream>

using namespace std;

// nase struktura
struct Prvek
{
    int iA;
    int iB;

    Prvek() { }
    Prvek(int a, int b) : iA(a), iB(b) { }
};

// pridava prvky do pole a pokud pole neexistuje,
// tak ho vytvori
void pridej(Prvek prvek, Prvek*& kam, int& velikost)
{
    // pokud nebude existovat pole prvku
    if (!kam)
    {
        kam = new Prvek(prvek.iA, prvek.iB);
    }
    // pokud pole prvku bude existovat,
    // tak ho zvetsi o 1 a prida novy prvek
    else
    {
        Prvek* temp = new Prvek[velikost + 1];
        memcpy(temp, kam, sizeof(Prvek) * velikost);
        *(temp + velikost) = prvek;
        delete[] kam;
        kam = temp;
    }
    velikost++;
}

void vypis(Prvek* prvky, int& velikost)
{
    for (int i = 0; i < velikost; i++)
    {
        cout << (prvky + i)->iA << endl << (prvky + i)->iB << endl;
    }
}

int main()
{
    // zaciname od 0, cili bez pole
    Prvek* prvky = 0;
    int velikost = 0;

    // pokud pridame prvek do neexistujiciho pole,
    // tak se pole vytvori a nastavi se ukazatel na prvni prvek v poli
    // pricemz aktualni velikost se meni dynamicky s rostoucim polem
    // velikost je podstate indexace...
    pridej(Prvek(10, 20), prvky, velikost);
    pridej(Prvek(30, 40), prvky, velikost);
    pridej(Prvek(50, 60), prvky, velikost);

    vypis(prvky, velikost);

    cin.get();
    return 0;
}

S memcpy() treba v c++ davat pozor, v tomto pripade je to v pohode, ale akonahle by bol v strukture Prvek daky dynamicky typ, napr string tak by nastal pruser :) 

#4 vitamin
Tak v tom případě by se použilo std::copy místo memcpy :)