Konstruktor frage c++

Mechanics

Wenn der Speicher voll ist, musst du neuen Speicher anlegen. Da ist aber nichts drin. Also musst du die Objekte aus dem alten Speicher in den neuen rüberkopieren (aber nur so viele, wie im alten drin waren), und dann den alten freigeben.
Normalerweise programmiert man das alles so nicht. Wie schon ganz am Anfang geschrieben, würde man eher einen std::vector benutzen, damit wär das alles viel einfacher sicherer. Aber einmal muss man das halt verstanden haben.

Zalo3


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

if(m_nextFree == m_arraySize ){
	int newSize = m_arraySize*2;
	CRectangle* newRectangle = new CRectangle [ newSize];
    for(int i = 0; i<(m_arraySize);i++){
  
		newRectangle[i] = m_rectangles[i];
		
    }
    delete[] m_rectangles;
    m_rectangles = newRectangle;

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

Das mache ich also wenn Speicher voll ist ?

soll ich for schleife über arraysize gehen?

Mechanics

Fast...
Die letzten beiden Zeilen solltest du aus dem if rausziehen, denn das willst du auf jeden Fall machen, auch wenn der Speicher schon von vornherein gereicht hat.
Und jetzt fehlt noch das mit 100... Das musst du in die Berechnung von newSize einbeziehen.

Zalo3

Habe jetzt doch wieder Hoffnung geschöpft.
Ist wie eine Achterbahnfahrt.

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


if(m_nextFree == m_arraySize ){
	int newSize = m_arraySize*2;
	CRectangle* newRectangle = new CRectangle [ newSize];
    for(int i = 0; i<(m_arraySize);i++){

		newRectangle[i] = m_rectangles[i];

    }
    delete[] m_rectangles;
    m_rectangles = newRectangle;

    m_arraySize = newSize;

    if(m_arraySize < 100){

    	newSize = m_arraySize*2;
    }

    else{
    	    newSize = m_arraySize+100;
         }
    }

     m_rectangles[m_nextFree] = rectangle;
     m_nextFree++;

     }

Das wars?

Zalo3

Was machst du beruflich Mechanics?

Mechanics

Ich bin Softwareentwickler, wenn man auch die Arbeit als Werkstudent mit dazuzählt, dann schon seit über 10 Jahren.

Das mit dem newSize ist immer noch derselbe Quatsch. Ich weiß nicht, wie ich das sonst erklären soll.... Das if/else ist nicht schlecht. Aber das musst du machen, BEVOR du neuen Speicher anlegst und kopierst.

Zalo3

Aber wenn ich jetzt das vor der Speicher Anlegung mache ,dann müsste ich ja den alten Speicher sozusagen anlegen und denn dann vergrössern?

Hatte nicht jemand von euch gesagt ,dass man das nicht machen kann ?

Dann würde ich es so machen:

 
void CDrawing::add(const CRectangle& rectangle){
	
	  if(m_arraySize < 100){

	    	m_rectangles[ m_arraySize*2] = rectangle;
	    }

	    else{
	    	    m_rectangles[m_arraySize+100] = rectangle;
	         }
	    
if(m_nextFree == m_arraySize ){
	int newSize = m_arraySize*2;
	CRectangle* newRectangle = new CRectangle [ newSize];
    for(int i = 0; i<(m_arraySize);i++){

		newRectangle[i] = m_rectangles[i];

    }
    delete[] m_rectangles;
    m_rectangles = newRectangle;

    m_arraySize = newSize;

}

     m_rectangles[m_nextFree] = rectangle;
     m_nextFree++;

     }

Swordfish

Rück Deinen Code anständig ein!!

Das if - else am Anfang: m_rectangles zeigt auf Speicher mit den Plätzen von 0 bis m_arraySize - 1 ... Du kannst nicht einfach m_rectangles[m_arraySize * 2] oder m_rectangles[m_arraySize + 100] etwas zuweisen! Weg damit!

Der rest ist Ok, fehlt nur noch, daß laut Aufgabenstellung newSize abhängig von der alten Größe m_arraySize unterschiedlich berechnet wird. Aber das habe ich Dir weiter oben schon vorgepredigt:

@swordfish sagte in Konstruktor frage c++:

@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

Gut ich habe es so gemacht wie du gesagt hast .

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

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

if(m_nextFree == m_arraySize ){
	int newSize = m_arraySize*2;
	CRectangle* newRectangle = new CRectangle [ newSize];
    for(int i = 0; i<(m_arraySize);i++){

		newRectangle[i] = m_rectangles[i];

    }
    delete[] m_rectangles;
    m_rectangles = newRectangle;

    m_arraySize = newSize;

}

     m_rectangles[m_nextFree] = rectangle;
     m_nextFree++;

     }

Aber bitte noch um eine kleine Erklärung kann ich sozusagen mit dem size_t auch weiter oben auf den neuen Speicher zugreifen oder wie?

Also sol wie mein code jetzt geht steht würde passen ?
Wir haben size_t nie benutzt

Mechanics

Irgendwie ist es zum Heulen

Zalo3

Oh nein immer noch falsch oder wie ?

Mechanics

Das sind doch nur paar Zeilen Code, siehst du nicht, was du machst?
Die newSize Berechnung ganz oben schaut schon mal richtig aus, aber warum ganz oben? Das brauchst doch erst, wenn du festgestellt hast, dass der Speicher nicht reicht.
Und an der richtigen Stelle fängst du schon wieder an, newSize auszurechnen, und zwar falsch.

Swordfish

@zalo3 sagte in Konstruktor frage c++:

Aber bitte noch um eine kleine Erklärung kann ich sozusagen mit dem size_t auch weiter oben auf den neuen Speicher zugreifen oder wie?

Du kannst auf nix zugreifen, daß es an der Stelle noch nicht gibt. std::size_t ist bloß ein weiterer Datentyp wie auch char, int, float, std::string ... für den garantiert ist, daß er groß genug für alle Speichergrößen ist.

Zu Deinem Code:

@zalo3 sagte in Konstruktor frage c++:

Gut ich habe es so gemacht wie du gesagt hast .

// ...

if(m_nextFree == m_arraySize ){
	int newSize = m_arraySize*2; // hier ...
	CRectangle* newRectangle = new CRectangle [ newSize];
	// ...

... berechnest Du bisher die neue Größe. Warum also nicht auch hier die Entscheidung, wie viel mehr Speicher in Abhängigkeit von m_arraySize?

Zalo3

 void CDrawing::add(const CRectangle& rectangle){
        if(m_nextFree == m_arraySize ){
	    std::size_t newSize;
		if( m_arraySize < 100 ){
		    newSize = m_arraySize * 2;
		}
		else{
		    newSize = m_arraySize + 100;
		}
	CRectangle* newRectangle = new CRectangle [ newSize];
    for(int i = 0; i<(m_arraySize);i++){

		newRectangle[i] = m_rectangles[i];

    }
    delete[] m_rectangles;
    m_rectangles = newRectangle;

    m_arraySize = newSize;

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

     }

Was ich nicht erstehe warum ich da das size_t bastele ?
Was bewirkt das ?
Damit ich es nächstes mal auch machen kann.

Mechanics

Schaut soweit richtig aus.
size_t ist praktisch ein int. Diese Datentypen haben verschiedene Wertebereiche. Der vom int ist z.B. nicht definiert, bei VS ist er auch unter 64Bit 32 Bit groß und geht damit ungefähr -2 Mrd bis +2 Mrd. Damit könntest du keine 3 Mrd Rectangles speichern.
Der size_t ist vorzeichenlos und bei dem ist garantiert, dass du so viele Elemente speichern kannst, wie du Speicher hast.
Für deinen Fall kannst du auch int schreiben, das wär auch egal, aber size_t wär der korrekte Datentyp.

Swordfish

@zalo3 sagte in Konstruktor frage c++:

// ...

Na endlich.

@zalo3 sagte in Konstruktor frage c++:

Was ich nicht erstehe warum ich da das size_t bastele ?
Was bewirkt das ?

Du kannst auch einen int oder sonstwas basteln. Es ist halt nur für std::size_t garantiert, daß der Typ groß genug ist für alles, was im Speicher rumliegt.

Zalo3

jaaaaaaaaaaaa endlich geschafft .

JETZT kann ich mich an die Ausgabe der print Methode machen (von Aufgabe)oder es einfach lassen .
Wahrscheinlich würde ich weitere 8h brauchen

Swordfish

@zalo3 sagte in Konstruktor frage c++:

JETZT kann ich mich an die Ausgabe der print Methode machen

omg. bitte nicht, wenn Du es vermeiden kannst.

Zalo3

Ja ehrlich gesagt . Ich lasse es . Eine 1.0 werde ich sowieso nicht in Klausur schaffen.
Ziel bleibt das bestehen .
Wäre für mich auch mehr als genug.
Wahrscheinlich werde ich mich vielleicht an ner anderen AUfgabe ran wagen.
Aber das problem ist ,dass ich das implementieren mit algorithmen usw einfach nicht selber schaffe.