Konstruktor frage c++

Zalo3

 
 
 void CDrawing::add(const CRectangle& rectangle){
	
	
	if(m_nextFree < m_arraySize ){
	m_rectangles[m_nextFree] = rectangle;
	
	}
	
	if(m_nextFree < 100){
		CRectangle* newRectangle = new CRectangle [m_arraySize -1];
		delete[] m_rectangles;
		newRectangle[2*m_nextFree] = rectangle;
		
		
		
	}
	
	if(m_nextFree >=100 && m_nextFreee == m_arraySize){
		newRectangle[m_nextFree+100] = rectangle;
		m_nextFree++;
		
	}


}

Habe die if Bedingung nochmal mit m_nextFree korrigiert .
Jetzt müsste es ja passen.

Mann kann hier nicht editieren

Swordfish

@zalo3 Hinter dem 3-Punkte-Menü rechts unter Deinen Beiträgen verbirgt sicht der Menüpunkt "Bearbeiten" ... wäre besser Deine Posts zu korrigiere, solange noch niemand geantwortet hat, statt ständig neu zu posten mit Miniänderungen.

Mechanics

Ich weiß nicht, ob dir das hilft, aber Programmieren ist komplett logisch. Es passiert genau das, was dransteht.
Also versuch mal, dein Programm im Kopf Zeile für Zeile durchzugehen und überleg dir, was passiert, und ob du das willst.

Swordfish

@zalo3 sagte in Konstruktor frage c++:

// ...

Ich hab' Dir doch oben ganz genau beschrieben, wie es geht??

Vorweg: CDrawing::m_nextFree und CDrawing::m_arraySize sollten wie alle Speichergrößen vom Typ std::size_t sein.

#include <algorithm> // für std::copy(), alternativ eine Schleife zum kopieren verwenden.

// ...

void CDrawing::add(const CRectangle& rectangle)
{
	if(m_nextFree == m_arraySize) { // Wenn m_nextFree == m_arraySize
		// neuen Speicher der von der Aufgabenstellung geforderten Größe besorgen:
		std::size_t new_size{ m_arraySize < 100 ? m_arraySize * 2 : m_arraySize + 100 };
		CRectangle * new_mem{ new CRectangle[new_size] };

		// alle Elemente 0 ... m_arraySize - 1 in den neuen Speicherbereich kopieren:
		std::copy(m_rectangles, m_rectangles + m_arraySize, new_mem);

		// den "alten" Speicher auf den m_rectangles zeigt entsorgen:
		delete[] m_rectangles;

		// m_rectangles auf den "neuen" Speicherbereich zeigen lassen:
		m_rectangles = new_mem;

		// m_arraySize auf den neuen Wert setzen:
		m_arraySize = new_size;
	}

	// Das übergebene rectangle an m_rectangles[m_nextFree] schreiben:
	m_rectangles[m_nextFree] = rectangle;

	// und m_nextFree inkrementieren:
	++m_nextFree;
}

Mechanics

Um den Fragesteller noch etwas zu verwirren: das ganze ist noch nicht 100% exception safe.

Zalo3

Naja das Problem das wir sachen wie size_t usw nicht benutzen .

Gibt es einen anderen Weg ?

Mechanics

Ich versteh dich nicht... Einerseits tust du was und machst auf mich nicht den Eindruck, als hättest du gar keinen Bock. Aber andererseits stellst du dich schon echt seltsam an.

Zalo3

Die Lösung von swordfish ist natürlich gut .
Aber wir haben diese Sachen ja gar nicht behandelt.

Mechanics

Verstehst du den Code? Wenn size_t das einzige ist, was dich stört, dann nimm halt int, wie bisher. Das mein ich damit, dass du dich seltsam anstellst. Das ist jetzt doch echt kaum noch der Rede Wert.
Und wegen dem copy steht sogar im Kommentar, dass man alternativ auch eine Schleife nehmen könnte.

Swordfish

@mechanics sagte in Konstruktor frage c++:

das ganze ist noch nicht 100% exception safe.

Wenn new[] wirft ist das Objekt doch im selben Zustand wie zuvor? Oder was genau meinst Du?

Zalo3

Ich habe es ein wenig nochmal über einen anderen Weg probiert

Aber verpeile plötzlich ,da ich merke ,dass ich ja jetzt irgendwie den Scheiss mit den 100 Elementen noch einbauen muss.
Drehe durch.

Soll ich dafür jetzt noch ne If Bedingung MACHEN wieder ?
Das kopieren von dem alten Array ins neue habe ich ja jetzt.

tut mir leid für die Ausdrucksweise . Hab keine Nerven mehr

 void CDrawing::add(const CRectangle& rectangle){




if(m_nextFree == m_arraySize ){


	CRectangle* newRectangle = new CRectangle [ m_arraySize*2];

	for(int i = 0; i<(m_arraySize*2);i++){

		newRectangle[i] = m_rectangles[i];

	}
	delete[] m_rectangles;
	m_rectangles = newRectangle;
	m_arraySize = (m_arraySize*2);

}
m_rectangles[m_nextFree] = rectangle;
m_nextFree++;


}

Was ist das genau mit den kleiner 100 Elementen genau ?
Speicher voll oder Speicher noch da? Ich denke Speicher da?
Dann wäre ja mein vergrössern des Arrays falsch?

Swordfish

@zalo3 sagte in Konstruktor frage c++:

	for(int i = 0; i<(m_arraySize*2);i++) {
		newRectangle[i] = m_rectangles[i];
	}

Das kannst Du nicht tunfisch, weil der Speicherbereich auf den m_rectangles zeigt nur m_arraySize Elemente lang ist und Du somit mit m_rectangles[i] mit einem i größer gleich m_arraySize auf Speicher zugreifst, der Dir nicht gehört.

@zalo3 sagte in Konstruktor frage c++:

Aber verpeile plötzlich ,da ich merke ,dass ich ja jetzt irgendwie den Scheiss mit den 100 Elementen noch einbauen muss.
Drehe durch.

Soll ich dafür jetzt noch ne If Bedingung MACHEN wieder?

Entweder wie ich oben geschrieben habe

std::size_t new_size{ m_arraySize < 100 ? m_arraySize * 2 : m_arraySize + 100 };

oder

std::size_t new_size;
if( m_arraySize < 100 )
    new_size = m_arraySize * 2;
else
    new_size = m_arraySize + 100;

@zalo3 sagte in Konstruktor frage c++:

Was ist das genau mit den kleiner 100 Elementen genau ?
Speicher voll oder Speicher noch da? Ich denke Speicher da?
Dann wäre ja mein vergrössern des Arrays falsch?

Sorry, nix verstehen.

@mechanics sagte in Konstruktor frage c++:

das ganze ist noch nicht 100% exception safe.

Aja, std::copy() kann werfen, wenn der copy-ctor wirft. Well ... shit happens.

Zalo3

Ich habe gerade ein kleines Problem ,was mir Schwierigkeiten macht die AUfgabe selbst zu lösen

 void CDrawing::add(const CRectangle& rectangle){




if(m_nextFree == m_arraySize ){


	CRectangle* newRectangle = new CRectangle [ m_arraySize];

	for(int i = 0; i<(m_arraySize);i++){

		newRectangle[i] = m_rectangles[i];

	}
	delete[] m_rectangles;
	m_rectangles = newRectangle;



}
m_rectangles[m_nextFree] = rectangle;
m_nextFree++;


}

CRectangle* newRectangle = new CRectangle [ m_arraySize];

Ich muss ja um ein neues array Speichergrösse festzulegen auch irgendwie so machen:
CRectangle* newRectangle = new CRectangle [ m_newSize];
Aber das m_newSize wird dann nicht erkannt ?

Wie soll ich es vorher definieren ?Das habe ich bei Speicher anlegen noch nie gemacht?
Da im Header bei unseren AUfgaben immer vorgegeben war ?
Kann mir das jemand erklären bitte

Ich will versuchen selbst auf die Lösung zu kommen .Wie swordfish gemacht hast verstehe ich zwar , aber ich will es auch gerne nochmal selber machen

Swordfish

@zalo3 sagte in Konstruktor frage c++:

Ich muss ja um ein neues array Speichergrösse festzulegen auch irgendwie so machen:
CRectangle* newRectangle = new CRectangle[m_newSize];
Aber das m_newSize wird dann nicht erkannt?

Dann wirst Du ein newSize wohl deklarieren und definieren müssen, bevor Du es verwendest.

Zalo3

ja habe es gerade gemacht. :smiling_face_with_open_mouth_closed_eyes:

Ich glaube,dass ich an der Lösung nah dran bin .
Melde mich in kürze.

Ich nerve euch bis ich es geschafft habe

Zalo3

 
void CDrawing::add(const CRectangle& rectangle){




if(m_nextFree == m_arraySize ){

    int m_newSize = m_arraySize*2;
	CRectangle* newRectangle = new CRectangle [ m_newSize];

	for(int i = 0; i<(m_newSize);i++){

		newRectangle[i] = m_rectangles[i];

	}
	delete[] m_rectangles;
	m_rectangles = newRectangle;
	
	m_arraySize = m_newSize;



}
m_rectangles[m_nextFree] = rectangle;
m_nextFree++;
if(m_arraySize < 100){
	m_newSize = m_arraySize*2;
}
else{
	m_newSize = m_arraySize+100;
}
}

Ich verstehe allerdings noch nicht gleich wo das eingebaut werden muss:
if(m_arraySize < 100){
m_newSize = m_arraySize*2;
}
else{
m_newSize = m_arraySize+100;
}

Da ja der Speicher so nicht erkannt wird ?

Jetzt langsam habe ich auch keine Idee mehr?

Swordfish

Würdest Du bitte deinen Code ordentlich einrücken und überflüssige Leerzeilen entfernen?

Ach, ich machs selbst:

@zalo3 sagte in Konstruktor frage c++:

void CDrawing::add(const CRectangle& rectangle)
 {
 	if (m_nextFree == m_arraySize) {
 		int m_newSize = m_arraySize * 2; // 1)
 		CRectangle* newRectangle = new CRectangle[m_newSize];

 		for (int i = 0; i < (m_newSize); i++) {
 			newRectangle[i] = m_rectangles[i]; // 2)
 		}

 		delete[] m_rectangles;
 		m_rectangles = newRectangle;
 		m_arraySize = m_newSize;
 	}
 
 	m_rectangles[m_nextFree] = rectangle;
 	m_nextFree++;
 
 	if (m_arraySize < 100) { // 3)
 		m_newSize = m_arraySize * 2; // 4)
 	}
 	else {
 		m_newSize = m_arraySize + 100;
 	}
 }

warum stellst Du einer lokalen Variable ein m_ voran ? Den Präfix verwendet man üblicherweise nur für Membervariablen um sie ohne this-> davor von etwaigen gleichnamigen Parametern unterscheiden zu können.
Du greifst mit m_rectangles[i] noch immer (oder schon wieder) auf Speicher zu, der dir nicht gehört wenn i größer gleich m_arraySize wird.
Ist hier fehl am Platz. Erstens soll das nur stattfinden wenn größerer Speicher besorgt werden muss und zweitens ist m_arraySize an dieser Stelle eventuell schon erhöht worden (int m_newSize = m_arraySize * 2; /* ... */ m_arraySize = m_newSize;)
m_newSize existiert hier nicht mehr sondern nur im Scope des if oben, da es darin deklariert wurde.

Zalo3

 
void CDrawing::add(const CRectangle& rectangle){

if(m_nextFree == m_arraySize ){

    int m_newSize = m_arraySize*2;
	CRectangle* newRectangle = new CRectangle [ m_newSize];

	for(int i = 0; i<(m_newSize);i++){

		newRectangle[i] = m_rectangles[i];

	}
	delete[] m_rectangles;
	m_rectangles = newRectangle;

	m_arraySize = m_newSize;

}

m_rectangles[m_nextFree] = rectangle;
m_nextFree++;

if(m_arraySize < 100){
	m_newSize = m_arraySize*2;
}

else{
	m_newSize = m_arraySize+100;
}


}

Soll ich den Speicher ausserhalb der if Bedingung schon erstellen?

Th69

So unbeholfen kann man doch nicht sein, oder?
@Swordfish hat dir doch den Code schon gezeigt...

@zalo3 sagte in Konstruktor frage c++:

Wie swordfish gemacht hast verstehe ich zwar

Das glaube ich dir daher nicht.

Zalo3

Keine Fehler

 void CDrawing::add(const CRectangle& rectangle){
	
	int m_newSize = m_arraySize*2;
	CRectangle* newRectangle = new CRectangle [ m_newSize];

if(m_nextFree == m_arraySize ){

    for(int i = 0; i<(m_newSize);i++){

		newRectangle[i] = m_rectangles[i];

	}
    
	delete[] m_rectangles;
	m_rectangles = newRectangle;

	m_arraySize = m_newSize;

}

     m_rectangles[m_nextFree] = rectangle;
     m_nextFree++;

if(m_arraySize < 100){
	
	m_newSize = m_arraySize*2;
}

else{
	
	m_newSize = m_arraySize+100;
}


}

Bin wie immer offen für Kritik?