[Klassen]Neues Objekt überschreibt altes teilweise?

LINT* objekt = new LINT(12);
LINT* temp = objekt;
LINT* dings = new LINT(345);

Ich erstelle also erst eine instanz von der Klasse LINT und initialisiere sie mit dem wert 12 der in den private Unsigned char pointer p* gespeichert wird.
Den zweiten Pointer darauf zeigen lassen funktioniert einwandfrei, aber in der dritten zeile erstellt er noch ein Objekt. Dieses Objekt ist dann auch vollkommen in Ordnung, allerdings überschreibt dessen p* das p* von objekt, der verwendet da nochmal die gleiche adresse (zeigt mir der debugger an)

Was kann ich tun um das zu verhindern?

asc

Trickiii schrieb:

Was kann ich tun um das zu verhindern?

Ich gehe mal davon aus, das du irgendwas falsch machst (Sei es nun das du eine static-Variable verwendest oder irgendwas anderes mit dem Zeiger anstellst). Ohne mehr Code lässt sich nichts sagen, den an sich sollte bei einer richtigen Implementation kein Problem entstehen...

cu André

class LINT
{
	private:
			Byte* p;                             
	public:
			LINT(ulong);               
			LINT(LINT&);  
			~LINT();                      
			Byte* getZahl();                
			Byte* add(Byte&);     
			Byte* sub(Byte&);                   
			bool vergl(Byte&);              
};

Das is die klassendefinition wobei Byte per typedef unsigned char sein soll.

LINT::LINT(ulong zahl)		
{
	//Zahl in p schreiben
	int temp[LEN]={'0'};
	Byte temp2[LEN]={'0'};

	ulong tempzahl;
	int i=0, faktor=1, abr=0;
	tempzahl = zahl;
	while (abr != 1)
	{
		if (tempzahl/10 == 0)
		{
			abr++;
		}
		else
		{
		tempzahl /= 10;
		faktor *= 10;
		temp[i] = zahl - tempzahl * faktor;
		temp[i] /= (faktor/10);
		temp2[i] = temp[i] + '0';
		i++;
		}
	}
	temp2[i] = tempzahl+'0';
	temp2[i+1] = ENDZ;
	p = temp2;
}

Das ist der Konstruktor wobei ulong per typedef unsigned integer sein soll.
Der Konstruktor soll die Int in den unsigned char array schreiben, ganz genau so wie er das auch tut.

Wenn der fehler noch wo anders liegen könnte sag bescheid wo, aber viel mehr code gibts im moment noch garnich

hustbaer

temp2 ist eine LOKALE Variable, die "verschwindet" wenn die Funktion (Konstruktor in dem Fall) beendet wird.
Logischerweise darfst du dir nicht die Adresse von einer solchen Variable merken und später damit weiterarbeiten.

Dass die Adresse der lokalen Variable in beiden Fällen gleich ist ist "Zufall" (=nichts worauf man sich verlassen könnte).

Ok danke wenn man mal drüber nachdenkt total logisch.
habs jetzt mal so gelöst:

Byte* temp3 = new Byte[LEN];
	for (int j=0; j < LEN; j++)
	{
		temp3[j] = temp2[j];
	}
	this->p = temp3;

Die klassenstruktur hatte unser prof so vorgeschlagen (fangen grad erst mit klassen an) Wäre es besser neben *p auch noch ein physikalisches array in private zu erzeugen oder könnte man das noch anders besser lösen?

asc

Trickiii schrieb:

...Die klassenstruktur hatte unser prof so vorgeschlagen...

Wieso war mir das vorher klar? Der Code sieht eindeutig nach Professor-Geprägt aus... (Ich kenne nur wenige wirklich gute Informatikprofessoren).

a) Unkonventionelle Schreibweise (Komplett groß geschrieben werden zumeist in der Praxis nur Makros)
b) C-mit-Klassen Stil
c) Unsitte im Header/bei der Klassendeklaration die Parameternamen weg zu lassen (Da man grundsätzlich "gegen die Schnittstelle, niemals die Implementierung" programmieren sollte, ist es sinnvoll wenn der Header selbsterklärend ist - um garnicht den Bedarf zu haben die Implementierung anzuschauen...).

Ganz davon abgesehen:
1. Wenn man den Kopierkonstruktor definieren muss, gilt das gleiche auch für den Zuweisungsoperator.
2. Der Kopierkonstruktor und Zuweisungsoperator sollten mit einer konstanten Referenz arbeiten:

class LINT
{
    public:
        LINT(ulong);
        LINT(LINT const &); // oder falls du eine andere Schreibweise vorziehst (const LINT&)
        LINT& operator=(LINT const &);
        ~LINT();
};

mammamia;