Anfängerfrage

abzy

Huhu!

Da ich bisher hier meist brauchbare Antworten bekommen habe, komme ich wiedermal mit einer Frage:

Man stelle sich 2 Klassen vor: a und b

Wenn ich in Klasse a die Klasse b aufrufe, also:

class a{
...
b myb(2);
int * xyz = b.getb();
...
}

class b{
...
int zyx;

b(int abc){
  zyx = abc;
}
int* getb(){
  int * p = &zyx;
  *p = zyx;
  return p;
}

Warum bekomm ich dann nur blödsinn raus beim Pointer in Klasse a?

Ich hab auch schon ausprobiert das es anders rum schon funktioniert. also eine Variable in a erzeugen und dann in b darauf zugreifen. in b erstellen und in a drauf zugreifen geht allerdings nicht. teilweise ja nachvollziehbar weil ich sonst gefahr laufen könnte das es die noch gar nicht gibt. Aber gibts trotzdem eine möglichkeit um auf sowas zugriff zu haben?

drakon

Warum bekomm ich dann nur blödsinn raus beim Pointer in Klasse a?

Sorry, aber diese Aussage ist Blödsinn.

Was passiet denn? Bring bitte mal konkreten Code, weil das, was du da gepostet hast, funktioniet beim besten Willen nicht..

Ich sehe eine Menge Probleme.

abzy

Was passiet denn? Bring bitte mal konkreten Code, weil das, was du da gepostet hast, funktioniet beim besten Willen nicht..

ja das es nicht geht weiß ich- danke

ich will ja wissen warum nicht.

Und doch der Code passt.

Nochmal was ich will: Eine Klasse A ruft eine Klasse B auf. In B wird eine Variable angelegt. Dann wird ein pointer erstellt der auf diese Variable in B zeigt. Diese Pointeradresse wird an A zurückgegeben. Wieso kommt bei der Rückgabe nur blödsinn raus? Eigentlich will ich jetzt in Klasse A die Variable in Klasse B ändern.

P.S: Ich hab durch ausprobieren auch schon rausgefunden das es über einen Pointer geht wenn ich ihn als referenz mitschicke. Aber würde trotzdem gern wissen wieso es als Rückgabewert nicht klappt

bwbg

Ich habe mal einen Blick in die Kristallkugel geworfen und es ist folgender wirrer Code bei rausgekommen (er kompiliert und lässt sich ausführen):

#include <iostream>

class A
{
private:
	int value_;

public:
	A(int value)
		: value_(value)
		{ }

	int* getValuePointer()
		{
			return &value_;
		}
};

class B
{
public:
	int* accessInnerA()
		{
			A aObj(123);
			int* a = aObj.getValuePointer();
			return a;
		}
};

int main()
	{
		A myA(456);
		B myB;

		int* crash = myB.accessInnerA();

		return EXIT_SUCCESS;
	}

Ich vermute mal stark, dass es dem entspricht, was du vorhast. Wenn dem so ist, dann lass es bleiben. Dass nur "Blödsinn rauskommt" ist reine Glücksache, genauso gut könnte dir dein Programm um die Ohren fliegen, weil hier (int crash*) einen Zeiger zugewiesen bekommt, auf ein Objekt, welches nicht mehr existiert.

ja das es nicht geht weiß ich- danke

Bitte, aber das "Dass" ist nicht hier nicht entscheidend, sondern das "Wie". Welche Ausgabe erwartest du? Was wird statt dessen ausgegeben? Usw.

Und doch der Code passt.

Nein, er passt ganz und gar nicht, weil er sich nicht übersetzen lässt. Des weitern lassen sich die Fragmente nur sehr schwer entziffern (Namenskonventionen, Einrücken, etc. macht auch Pseudo-Code lesbarer und verständlicher).

Weiterhin können sich Klassen nicht gegenseitig aufrufen. Klassen sind lediglich (wenn man von statischen Methoden absieht) leere Hüllen (oder "Baupläne", wie man in manchen Büchern lesen kann) und bedürfen immer konkreter Objekte (Instanzen).

Grüße... Heiko

drakon

ja das es nicht geht weiß ich- danke

Überhaupt nicht. In meinen Augen ist das kein Pseudocode und C++ Code auch nicht.

In Solchen Fällen hängt es von verschiedensten Faktoren ab, warum etwas geht, oder nicht geht. Darum solltest du FUNKTIONIERENDEN Code posten. (Also, was DU gemacht hast und dazu eine Frage stellen. Und mit funktionierende meine ich nicht, dass es so läuft, wie du willst,sondern dass es sich wenigstens compilen lässt, DAS hast du ja anscheinend hingekriegt.. Also warum noch lange um den heissen Brei reden..).

Nochmal was ich will: Eine Klasse A ruft eine Klasse B auf. In B wird eine Variable angelegt. Dann wird ein pointer erstellt der auf diese Variable in B zeigt. Diese Pointeradresse wird an A zurückgegeben. Wieso kommt bei der Rückgabe nur blödsinn raus? Eigentlich will ich jetzt in Klasse A die Variable in Klasse B ändern.

Zu dieser Frage kann man vieles verstehen. Vor allem der Ausdruck "Klasse A ruft Klasse B auf".

Aber wenn du so etwas, wie bwbg gemeint hast, dann stimme ich ihm zu mit dem, dass du die Finger davon lassen solltest, weil, wie gesagt du eine Adresse auf eine ungültige Stelle zurückgibst, was gut gehen kann, aber nicht muss.

abzy

ok ich versuch mal kurz zu beschreiben was ich machen wollte. Ich hab mal davon gelesen das einer eine Klasse geschrieben hat die verschiedene dynamisch angelegte variablen, objekte usw. verwaltet und beim beenden auch drauf achtet das diese wieder gelöscht werden.

Ich wollt das mal so grob probieren. Einfach zum lern und übrungszweck und weil mir die idee gefallen hat.

So nun bin ich aber an das Problem gestoßen das ich in dieser Klasse zwar dynamisch Variablen erstellen kann

a new int zb.

aber ich hab dann im Hauptprogramm keinen Zugriff darauf. Also dachte ich natürlich dran das ich die Speicheradresse die von new zurückgegeben wird dann auch gleich weiter gebe an das Hauptrogramm. Ich dachte das ich damit dann den Inhalt ändern könnte.

Und genau das habe ich oben versucht zu beschreiben. Ein Hauptprogramm ruft eine Klasse auf, die erzeugt eine Variable und im Hauptprogramm will ich dann Zugriff auf die haben.

edit:

weil hier (int* crash) einen Zeiger zugewiesen bekommt, auf ein Objekt, welches nicht mehr existiert.

Damit kann ich was anfangen. Danke

drakon

Könntest es auch so machen, dass du mit einem getter die Liste holst und dann alle Werte hast, oder du könntest der Klasse auch noch ein paar Methoden spendieren usw.

#include <iostream>
#include <list>

class foo {

public:
	~foo () //Destruktor wird aufgerufen und hier kann dann das aufräumen stattfinden
	{
		for(list_it it (list.begin ());it != list.end ();)
		{
			delete *it;
			it = list.erase (it);
		}
	}

	int* insert (int value) //Einen Wert einfügen (Könnte auch jedes 
            //beliebige Objekt sein. Integer macht eigl. nicht so viel Sinn. ;))
	{
		int* v = new int(value);
		list.push_back(v);		
		return v;
	}	

private:
	std::list<int*> list;
	typedef  std::list<int*>::iterator list_it;
};
int main ()
{
	foo f;
	int* p5 = f.insert (5);
	int* p2 = f.insert (2);

	std::cout << *p5 << std::endl;
	std::cout << *p2 << std::endl;

	return 0;
}