C++ dinamikus objektumtömb paraméteres konstruktorral

 ( lzrd | 2006. február 27., hétfő - 21:43 )

Üdvözletem!

Feltételezem, ha van mondjuk egy saját osztályom, myclass néven és szeretném példányosítani dinamikusan, ráadásul úgy, hogy ne csak egy darab álljon rendelkezésre, hanem sok, akkor
valami ilyesmi jó lehetne:

myclass * objektumtombmutato = new myclass[10];

Feltehetően létrejön egy 10 elemű tömb, ami myclass típusú objektumokból áll és az objektummutatotomb ennek a tömbnek az elejére mutat. De ha azt szeretném, hogy mind a tíz darabnak más paramétert tudjak adni a konstruktora számára, az lehetséges valahogy?

Köszi előre is!

Hozzászólás megjelenítési lehetőségek

A választott hozzászólás megjelenítési mód a „Beállítás” gombbal rögzíthető.

Nem. Mindig az alapértelmezett konstruktort hívja meg. Vagy myclass mutatókból csinálj tömböt, vagy használj vectort! Ezeknél utána manuálisan létrehozhatod az objektumokat. Én a vectorra szavazok...

KisKresz

Sima tömböt hoztam létre és nem konstruktorból, hanem függvénytagból állítom be az értékeket egy hívó osztály konstruktorában :)

Nem biztos, hogy teljesen értem, amit írtál, de ha jól sejtem, akkor létrehozod a tömböt (alapértelmezett konstruktorok), majd manuálisan az objektumokat (valamilyen konstruktor) és értékadással beteszed a tömbbe. Talán nem a legoptimálisabb eljárás, de ha nem lassú a programod, nem érdemes vele törődni!

KisKresz

Már értem, az előző hozzászólásom tárgytalan.

KisKresz

Sima tömböt hoztam létre és nem konstruktorból, hanem függvénytagból állítom be az értékeket egy hívó osztály konstruktorában :)

Sima tömböt hoztam létre és nem konstruktorból, hanem függvénytagból állítom be az értékeket egy hívó osztály konstruktorában :)

Elnézést! Nem volt szándékos a többszörözés!

inkább több sörözés! :)

dinamikus memoriakezeles + objektumok letrehozasa ciklusban

Eltunt a hozzaszolasom, itt van meg1x

class Foo
{
public:
	Foo();
	Foo(int var) {m_Var = var;};
private:
	int m_Var;
};

int main()
{
	Foo **myFoo;
	int cs;
	
	myFoo = new Foo*[20];
	for (cs = 0; cs < 20; cs++) {
		myFoo[cs] = new Foo(cs);
	}

	//...
	//delete...
}

esetleg ha már c++:

 
#include <vector>

int func1()
{
   std::vector<Foo*> myvect;
   for(int i=0; i<20; ++i)
      myvect.push_back(new Foo(i));

   //...felhasznalas...

   for(int i=0; i<myvect.size(); ++i)
      delete myvect[i];
}

sőt

 
#include <boost\shared_ptr>
#include <vector>

int func1()
{
   typedef boost::shared_ptr<Foo> SharedFoo_t;
   std::vector<SharedFoo_t> myvect;
   for(int i=0; i<20; ++i)
      myvect.push_back(SharedFoo_t(new Foo(i)));

   //...felhasznalas...

   //és nem kell explicit törlés!
}

Nyilvan en sem szorakozok pointer to pointer dolgokkal normalis esetben. Csak a nap elejen kiesett hozzaszolasokban, mintha ilyesmi lett volna a keres.
Tanulas szempontjabol sem rossz ez a sorrend. Eloszor ertse meg a pointert utana vectort, majd egy kis boost.

Ha valasztani kellene szerintem csinalja eloszor std::vector<*>-al.
Na ezt is tulragoztam.

Köszönöm! Nekilátok megérteni.

Üdvözletem!
Ismét én. Elnézést a lámaságért.
Nézegettem a cplusplus.com-ot és ott azt olvastam, hogy a paramétert nem használó konstruktorban is jó lenne inicializálni a változókat.
Erre kitaláltam a Dev-C++ segítségével az alábbi kódot:

#include
#include

using namespace std;

class Foo
{
public:
Foo(int var) {m_Var = var;};
int Get_variable() {return m_Var;};
Foo(){m_Var=111;};
private:
int m_Var;
};

int main(int argc, char *argv[])
{
Foo myclass(88);
Foo Mclass();
cout << endl << myclass.Get_variable();
cout << endl << Mclass.Get_variable();
cout << endl;
system("PAUSE");
return EXIT_SUCCESS;
}

Sajnos nem eszi meg a fordító. Tudom, hogy az én hibám, de nem értem mi a baj. Kérnék szépen egy kis segítséget (megoldást)! :)
Ez a hibaüzenet állott elő:

24 C:\Dev-Cpp\main.cpp request for member `Get_variable' in `Mclass', which is of non-class type `Foo ()()'

Köszönöm!

Anyázást, "hülyevagy"-ot nem kérnék, azt tudom, anyám meg nem tartozik másra!

sajnos amibe beleakadtál, az c++ "feature", bár szinte bug: a

Foo Mclass();

sort a fordító úgy értelmezi, hogy "egy Mclass nevű függvény, ami Foo értéket ad vissza". Neked a

Foo Mclass;

sor kell, ami nem kétértelmű.

Te nyertel;)

Upsz! Köszi!
Ez pont ellentétesnek tűnik azzal az elvvel, hogy ha nem a C++ fordító által generált automatikusan előállított konstruktorát használjuk, hanem készítünk sajátot, akkor a példány neve után zárójelezni kell. A gyakorlat miért mond ellent az elméletnek?

Foo Mclass;

Kipróbáltam. Dev-C++ így már megeszi.
Kár, hogy a cplusplus.com -on atutorialban erről nem szólnak semmit
:(

Idezet a http://www.cplusplus.com/doc/tutorial/classes.html oldalrol:

Important: Notice how if we declare a new object and we want to use its default constructor (the one without parameters), we do not include parentheses ():

CRectangle rectb; // right
CRectangle rectb(); // wrong!

Amindenit! Valóban!

Ezzel kavartam össze:

Here we have declared a constructor that takes two parameters of type int. Therefore the following object declaration would be correct:

CExample ex (2,3);

But,
CExample ex;

Would not be correct, since we have declared the class to have an explicit constructor, thus replacing the default constructor

Köszi!

Az alábbi programból kiindulva amolyan igazságtáblázat félét gyártattam a Dev-C++ -al:

01 #include
02 #include
03
04 using namespace std;
05
06 class Foo
07 {
08 public:
09 //Foo ()
10 Foo () { m_Var = 88;};
11 Foo(int var) {m_Var = var;};
12 // int Get() { return m_Var ;};
13 private:
14 int m_Var;
15 };
16
17 int main(int argc, char *argv[])
18 {
19 Foo myclass1;
20 // Foo myclass1();
21 // cout << myclass1.Get();
22 system("PAUSE");
23 return EXIT_SUCCESS;
24 }

Igazságtábla:
Műxik ezekkel a sorokkal

09 Foo();
10 //Foo () { m_Var = 88;};
12 //int Get() { return m_Var ;};
19 //Foo myclass1;
20 Foo myclass1();
21 //cout << myclass1.Get();

09 //Foo ();
10 Foo () { m_Var = 88;};
12 //int Get() { return m_Var ;};
19 //Foo myclass1;
20 Foo myclass1();
21 //cout << myclass1.Get();
vagy!
09 //Foo ();
10 Foo () { m_Var = 88;};
12 //int Get() { return m_Var ;};
19 Foo myclass1;
20 //Foo myclass1();
21 //cout << myclass1.Get();

09 //Foo ();
10 Foo () { m_Var = 88;};
12 int Get() { return m_Var ;};
19 Foo myclass1;
20 //Foo myclass1();
21 cout << myclass1.Get();

-