Copy-Konstruktor und dynamisch reservierten Arrays

Halte ich es kurz und klar - um zu üben dynamisch zugewiesenen Speicher, entschied ich mich zu einem Kreis, in dem ich speichern Sie die Parameter (X und Y der Mittelpunkt und radius Länge) in einen dynamisch zugewiesenen Arrays. Da das array dynamisch allokiert dies bedeutet, dass, um zu stoppen Sie ein Leck habe ich einen Konstruktor implementieren. Es bedeutet auch, dass, um zu vermeiden, dass ein paar andere Fehler, die ich implementieren müssen einen kopierkonstruktor und überlastung der Zuweisungsoperator. (mit so ziemlich den gleichen code) ich glaube, ich habe den Destruktor implementiert einigermaßen gut. Ich brauche ein bisschen Hilfe mit dem copy-Konstruktor, obwohl.

#include <iostream>

using namespace std;

class Circle
{
private:
    int* data;
public:
    Circle(){
        cout <<"I am the default constructor" << endl;
        data = NULL;
    }
    Circle(int* p){
        cout <<"I am the set up constructor" << endl;
        data = p;
    }
    ~Circle(){
        cout <<"I am the destructor" << endl;
        delete data;
    }
    Circle& operator=(const Circle& tt1){
        cout << "Overloaded assignment operator reporting in!" << endl;
        if(this != &tt1){
            //free old data
            delete this->data;
            data = new int(3);
           *data = *(tt1.get_data());
            *(arr+1) = *(tt1->get_data()+1);
            *(arr+2) = *(tt1->get_data()+2);
            return *this;
        }
    }
    Circle(const Circle& tt1){
        cout << "I am the copy constructor!" << endl;
        if(this != &tt1){
            //free old data
            delete this->data;
            data = new int(3);
           *data = *(tt1.get_data());
            *(arr+1) = *(tt1->get_data()+1);
            *(arr+2) = *(tt1->get_data()+2);
            return *this;
        }
    }
};

int main(){
    //is this object constructed well?
    int arr [] = { 16, 2, 7};
    Circle a(arr);

    return 0;
}

Anmerkungen: 1) new int(3) tun nicht, was Sie erwarten, es zu tun (data = new int[3]). 2) Für jede new[] Sie brauchen eine delete[] (delete[] data). 3) int arr[] = {1,2,3}; int * ptr = arr; delete[] ptr; verursacht Undefiniertes Verhalten (Eselsbrücke: hast du new[]? Wenn Sie nicht, ? delete[] falsch sein).
codereview.stackexchange.com
Wo ist der Merksatz?

InformationsquelleAutor Stanimirovv | 2013-05-25

c++dynamic memory

4
```
//is this object constructed well?
int arr [] = { 16, 2, 7};
Circle a(arr);
```
Die Antwort ist "ja" und "Nein": Ihr Konstruktor nicht eine Kopie des Arrays, die Sie nur Kopien ein Zeiger auf das erste element eines Arrays. Also, wenn Sie nicht möchten, dass Ihre Circle Klasse zu eigenen array, brauchen Sie nicht zu bieten, Destruktor, copy-Konstruktor oder Zuweisungsoperator.

Aber es ist wahrscheinlicher, dass Sie tun möchten, dass Ihre Klasse zu besitzen das array, in welchem Fall Sie benötigen, um eine lokale Kopie und speichern Sie es. Damit dies funktioniert, müssen Sie eine zusätzliche information: die Größe des Arrays, das ist völlig verloren, wenn übergeben (und implementieren der Destruktor, copy-Konstruktor, Zuweisungs-operator) einer Funktion, die einen Zeiger.

Bearbeiten denn dies ist eine übung, bei der dynamischen Zuweisung in dem Fall, wo das Eingangs-array ist immer die Größe 3 ist, dann ist dies ein Beispiel für einen Konstruktor, indem Sie eine Reihe:
```
Circle(int* p)
{
  data = new int[3];
  std::copy(p, p+3, data); //UB if p doesn't point to an array of at least 3 elements
}
```
Müssen Sie rufen Sie delete[] im Destruktor, da Sie genannt new[]:
```
~Circle()
{
    delete [] data;
}
```
Bei der Umsetzung der Zuweisungsoperator prüfen, die copy und swap-idiom.

Ja, ich will die Klasse besitzen die array. Da bin ich immer genau 3 Elemente, kann ich direkt vorbei ? Auch, was wäre eine richtige Konstruktion eines Objekts, besitzt das array?
wenn die Größe immer drei, dann Sie wahrscheinlich nicht wollen, die dynamische Zuordnung. Also, was sind die realen Zwängen?
Ich Stimme zu, dass es schlechtes design, es zu tun mit dynamischen Speicher, aber ich bin jetzt das erlernen der Nutzung der copy-Konstruktor und auch wenn dies nicht ein gutes Beispiel, ich möchte, um zu sehen, dass es funktioniert (mein plan ist die Umsetzung meiner eigenen version eines Vektors ein bisschen später, deshalb bin ich mit Hilfe eines dynamisch reservierten Arrays)
Ich habe einen Konstruktor und einen Destruktor. Mit der ehemaligen, können Sie wahrscheinlich herausfinden, der copy-Konstruktor und Zuweisungsoperator.
Ich denke, ich kann herausfinden, der rest ist auf meinem eigenen. Danke!!!

InformationsquelleAutor juanchopanza

-2

Schreibe ich einen richtigen code über Ihre Praxis, ich hoffe das kann dir helfen. Ich Baue diese von tdm-gcc und es gut laufen.

#include<iostream>
#include<algorithm> //std::copy
using namespace std;

class Circle {
private:
 int* data;

public:
 Circle(){
  cout <<"I am the default constructor" << endl;
  data = NULL;
 }

 Circle(int* p){
  cout <<"I am the set up constructor" << endl;
  data =new int[3];
  copy(p,p+3,data);
 }

 ~Circle(){
  cout <<"I am the destructor" << endl;
  if (data!=NULL) {
   delete[] data;
  }
 }

 Circle(const Circle& tt1){
  cout << "I am the copy constructor!" << endl;
  if (this != &tt1) {
   if (data!=NULL) {
    delete[] data;
   }

   data = new int[3];
   *data = *(tt1.get_data());
   *(data+1) = *(tt1.get_data()+1);
   *(data+2) = *(tt1.get_data()+2);
  }
 }

 Circle& operator=(const Circle& tt1){
  cout << "Overloaded assignment operator reporting in!" << endl;
  if (this != &tt1) {
   if (data!=NULL) {
    delete[] data;
   }
   data = new int[3];
   *data = *(tt1.get_data());
   *(data+1) = *(tt1.get_data()+1);
   *(data+2) = *(tt1.get_data()+2);
  }
 }

 int* get_data() const {
  return data;
 }
};

int main(){
 int arr[]={16,2,7};
 Circle a(arr);
 cout<<*a.get_data()<<'\t'
 <<*(a.get_data()+1)<<'\t'
 <<*(a.get_data()+2)<<endl<<endl;

 return 0;
}

Nur eine Anmerkung: Nicht erforderlich, zu prüfen, Zeiger für NULL vor dem löschen.
Ich bin mir nicht sicher, was Sie sagen, ist richtig. Aber ich danke Ihnen sehr.
Es ist. Man konnte Lesen, über die es in § 5.3.5 (2, 6, 7) - C++ - Standard
Es gibt keine Notwendigkeit zu prüfen, für die selbst-Zuordnung in einem copy-Konstruktor, es ist umstritten, ob es eine gute Idee, in einem Zuweisungsoperator (es kann automatisch ausblenden buggy-code), gibt es keine Notwendigkeit für get_data, und Sie können std::copy zum kopieren der Elemente von einem Circle zu den anderen.
get_data ist redundant, aber das ist nur eine Praxis ist, nutzen viele die Möglichkeiten, die ich denke, ist godd, Stimmen Sie mir zu? Vielen Dank für Ihre Beratung. @juanchopanza

InformationsquelleAutor jie

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.