C++ dinamikus objektumtömb paraméteres konstruktorral

Fórumok

Ü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ások

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

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

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.

Ü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!

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();