class A {
public:
	int i;
	A(int j){i=j;}
};

.. eine Methode die eine Liste von Referenzen auf A-Klassen konstruiert und einen Pointer auf die Liste zurück gibt ..

list<A*>* test()
{
	list<A*> *l = new list<A*>();
	{
		A a(1);
		cout << &a << endl;
		l->push_back(&a);
	}
	{
		A a(2);
		cout << &a << endl;
		l->push_back(&a);
	}

	cout << l->front() << endl;
	cout << l->back() << endl;

	cout << l->front()->i << endl;
	cout << l->back()->i << endl;

	return l;

}

.. und die Main-Methode.

int _tmain(int argc, _TCHAR* argv[])
{
	list<A*> *l = test();

	cout << l->front() << endl;
	cout << l->back() << endl;

	cout << l->front()->i << endl;
	cout << l->back()->i << endl;

	pause();
	return 0;
}

Das für mich Unverständliche: Innerhalb der Methode werden die Membervariablen richtig ausgelesen (i = 1 bzw. 2). Außerhalb stimmen zwar alle Referenzen überein, aber der Wert der Membervariablen ist ein völlig anderer. Beispiel für eine Ausgabe:

0012FD10
0012FD0C
0012FD10
0012FD0C
1
2
0012FD10
0012FD0C
3510704
3510768

Kann jemand nachvollziehen was da passiert? Gruß

/edit: puh, ich bin tatsächlich etwas erschöpft. ^^

int main() {
   list<A> List;
   List.push_back(1); // implizite Konvertierung ruft A::A(int) auf
   List.push_back(2);

   cout << List.front().i << endl;
   cout << List.back().i << endl;
//...

So einfach kann das Leben in C++ sein ...

"Initfunktionen" (wie bei Dir "test") sind unüblich und fehleranfällig - kann man (wenn man es braucht) viel besser in einem Konstruktor machen:

struct myListObject {
   list<A> internList;
   myList() {
      internList.push_back(1); // implizite Konvertierung ruft A::A(int) auf
      internList.push_back(2);
   }
};

int main() {
   myListObject List;

   cout << List.internList.front().i << endl;
   cout << List.internList.back().i << endl;
//...

Gruß,

Simon2.

@Simon2
Das sieht zwar wie eine init aus ist aber keine. Es ist nur eine Vereinfachung von Code den ich benutze und der im Grunde so funktionieren soll (Methode die eine Liste von Objekten zurückgibt).

Danke euch beiden schonmal. Hier jetzt der neue Code. Was ich jetzt noch nicht verstehe ist wie ich die anderen '->' und das 'new' wegmachen soll. Mir ist klar, dass ich die Liste einfach mit list<A> l; deklarieren kann. Aber wenn ich das richtig verstanden habe, ist die Liste futsch sobald ich aus der Methode zurückkehre (und nur einen Pointer zurückgebe). Also ist doch 'new' die einzige Alternative oder?

class A {
public:
	int i;
	A(int j){i=j;}
};

list<A>* test()
{
	list<A> *l = new list<A>();
	{
		A a(1);
		l->push_back(a);
	}
	{
		A a(2);
		l->push_back(a);
	}

	cout << l->front().i << endl;
	cout << l->back().i << endl;

	return l;

}

/* Main-Methode */
int _tmain(int argc, _TCHAR* argv[])
{
	list<A> *l = test();

	cout << l->front().i << endl;
	cout << l->back().i << endl;

	pause();
	return 0;
}

list<A>* test()
{
	list<A> *l = new list<A>();

	l->push_back(1);
	l->push_back(2);

	cout << l->front().i << endl;
	cout << l->back().i << endl;

	return l;

}

mit impliziter Konvertierung. Nettes Feature

void test(list<A>& l)
{
    l.push_back(A(1));
    l.push_back(A(2));
    cout << l.front().i << endl;
    cout << l.back().i << endl;
}

/* Main-Methode */
int _tmain(int argc, _TCHAR* argv[])
{
    list<A> l;
    test(l);   
    cout << l.front().i << endl;
    cout << l.back().i << endl;

    pause();
    return 0;
}

[edit]Pfeile wegeditiert [edit]

class A { 
public: 
    int i; 
    A(int j){i=j;} 
}; 

list<A> test() 
{ 
    list<A> l; 
    l.push_back( A(1) ); 
    l.push_back( A(2) ); 

    cout << l.front().i << endl; 
    cout << l.back().i << endl; 

    return l; 
} 

/* Main-Methode */ 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    list<A> l = test(); 

    cout << l.front().i << endl; 
    cout << l.back().i << endl; 

    pause(); 
    return 0; 
}

...
...Aber wenn ich das richtig verstanden habe, ist die Liste futsch sobald ich aus der Methode zurückkehre (und nur einen Pointer zurückgebe). Also ist doch 'new' die einzige Alternative oder?...

Nö,

ich würde solche "Erzeugerfunktionen" komplett meiden. Hat man nur Ärger mit.

Gruß,

Simon2.

Es würde z.Bsp. auch gehen indem du test eine Referenz auf deine List übergibst....

Mach doch mal eben die versehentlich kopierten Pfeilchen weg...

Gruß,

Simon2.

ich würde solche "Erzeugerfunktionen" komplett meiden. Hat man nur Ärger mit.

factory method? in diesem fall wissen wir doch gar nicht genau, was der OP vorhat.

OP schrieb:

Aber wenn ich das richtig verstanden habe, ist die Liste futsch sobald ich aus der Methode zurückkehre (und nur einen Pointer zurückgebe). Also ist doch 'new' die einzige Alternative oder?

ja, die liste ist weg, wenn du sie einfach so aus der funktion zurückgibst (per value, s.o. LordJaxoms posting). aber eine kopie wird erzeugt (inklusive kopien der objekte, die in der liste sind), diese kannst du dann weiter verwenden.

moderne compiler sind außerdem so schlau, dass sie auf die kopie verzichten (und das meinte IMO auch LordJaxom mit "keine kopierphobie"). stichwort dazu: (named) return value optimization.

Simon2 schrieb:

Aber wenn ich das richtig verstanden habe, ist die Liste futsch sobald ich aus der Methode zurückkehre (und nur einen Pointer zurückgebe). Also ist doch 'new' die einzige Alternative oder?

...

Das habe ich nicht gesagt !!

Braunstein schrieb:

Erledigt.

Danke !

Gruß,

Simon2.

Das habe ich nicht gesagt !!

passiert heute wohl allen mal ^^.
aber interessanterweise habe ich auch dich zitiert und etwas dazugeschrieben, das nicht mehr da war... wie auch immer, ist korrigiert