Versuch Wert zuzuweisen * dieser Zeiger nicht

Question

ich dieses Programm in C++ bekam und es funktioniert perfekt in Ordnung, wenn ich letzten 2 Zeilen in Kommentar gesetzt: a = b; MyAr c(b); ich es mit einem Verfahren getestet, das ich es gelöscht. Das Problem ist mit dem *this Zeiger ich denke, wenn ich kompiliere und laufe das Programm für einen Moment blinkt und dann verschwindet. Kannst du mir bitte helfen? Vielen Dank!

#include <iostream> 
using namespace std; 

class MyAr { 
    int *p; 
    int len; 
    public: 
     MyAr(); 
     MyAr(int a); 
     MyAr(const MyAr& ob); 
     ~MyAr(); 

     MyAr& operator=(const MyAr& ox) { *this = ox; } 
     int& operator[](int i) { return p[i]; } 
     int length(); 
}; 

MyAr::MyAr() : p(0), len(0) {} 
MyAr::MyAr(int a) : p(new int[a]), len(a) {} 
MyAr::MyAr(const MyAr& ob) { *this = ob; } 
MyAr::~MyAr() { delete p; } 

int MyAr:: length(){ 
    return len; 
} 

int main(){ 

    MyAr a; 
    MyAr b(10); 
    for(int i=0; i< b.length(); ++i) 
     b[i] = i; 

    a = b; 
    MyAr c(b); 

    system("pause"); 
    return(0); 
} 

Answer 1

Eines der wichtigsten Dinge, die Sie jemals in c tun ++ ist lernen richtig zu schreiben Konstruktoren und Destruktoren:

#include <cassert> 
#include <cstring> 
#include <utility> 

class MyAr { 
    int *p; 
    int len; 

public: 

    MyAr() : p(nullptr), len(0) {}; 
    MyAr(int a) : p(new int[a]), len(a) {}; 

    // because we are overloading the destructor, rule of 3 is required (c++03) 

    MyAr(const MyAr& ob) 
    : p(nullptr), len(ob.len) 
    { 
     if (len) { 
      assert(ob.p); 
      p = new int[len]; 
      std::memcpy(p, ob.p, len); 
     } 
    } 

    MyAr& operator=(const MyAr& r) 
    { 
     MyAr tmp(r); 
     swap(tmp); 
     return *this; 
    } 

    ~MyAr() { 
     // note: delete [] 
     delete [] p; 
    } 

    // or rule of 5 (c++11) 

#if __cplusplus >= 201103L 

    MyAr(MyAr&& r) 
    : p(r.p) 
    , len(r.len) 
    { 
     r.p = nullptr; 
     r.len = 0; 
    } 

    MyAr& operator=(MyAr&& r) 
    { 
     auto tmp = MyAr(std::move(r)); 
     swap(tmp); 
     return *this; 
    } 

#endif 

    void swap(MyAr& other) 
    { 
     using std::swap; 
     swap(p, other.p); 
     swap(len, other.len); 

    } 

    int& operator[](int i) { return p[i]; } 
    int length(); 
}; 

Answer 2

Die Definition

MyAr& MyAr::operator=(const MyAr& ox) { *this = ox; } 

ist, da die Zuordnung rekursiv, *this = ox wieder den überladenen Zuweisungsoperator aufruft. Sie haben also eine unendliche Rekursion (vermutlich zur endgültigen Beendigung Ihres Programms).

Es ist das gleiche die folgende Funktion als Aufruf:

void f() { f(); } 

Oder Sie in englischer Sprache, die Bedeutung von „zuweisen von Wert ox“ zu sein „von Wert zuweisen ox“ definiert haben, wenn das, was Sie es ist wirklich notwendig zu definieren, was es in Bezug auf die konstituierende Struktur Ihres Typs bedeuten soll!

Zum Beispiel:

MyAr& MyAr::operator=(const MyAr& ox) { 
    delete [] a; 
    a = nullptr; 
    len = 0; 

    return *this; 
} 

(Dies kann nicht die Semantik haben Sie wünschen, ändern zu schmecken.)