c++ - 割り当てのオーバーロードは明示的にデストラクタを呼び出します (他のバイナリオーバーロードされた演算子の実行後)

Question

私の問題は簡単です(ダブルフリーまたは破損(fasttop):)。これには解決策があります( here )。しかし、私はそれを実装できませんでした。どこに問題があるのかわからない。プログラムをトレースすると、二項演算子の実行後に発生することがわかりました...例として;

arr1 = arr2 + arr3;

このステートメントを実行すると、デストラクタが呼び出されます。したがって、私のデストラクタはスコープの終わりを呼び出して、必要以上に呼び出されるようにします。私のクラスの定義は次のとおりです。

class IntArray
{
public:
    IntArray(int size);
    //IntArray(const IntArray& ref);
    ~IntArray();
    IntArray& operator= (const IntArray&);
    const int& operator[] (int index) const;
    friend ostream& operator <<(ostream&, IntArray);
    friend istream& operator >>(istream&, IntArray);
    friend IntArray operator *(const IntArray&, const IntArray&);
    friend IntArray operator +(const IntArray&, const IntArray&);
    friend IntArray operator -(const IntArray&, const IntArray&);
    friend bool operator ==(const IntArray&, const IntArray&);
    friend bool operator <(const IntArray&, const IntArray&);
    friend bool operator >(const IntArray&, const IntArray&);
    const int& getArr(const int index) const{
        return arr[index];
    }
    void setArr(int value, int index){
        arr[index] = value;
    }
private:
    int* arr;
    int sz;
};

そして私のデストラクタは;

IntArray::~IntArray(){
    delete[] arr;
}

そして、私のバイナリオーバーロード関数の1つ。

 IntArray operator- (const IntArray& refOne, const IntArray& refTwo){
        IntArray newArray(refOne.sz);
        int value;
        for(int i = 0; i < refOne.sz-1; i++){
                value = refOne.getArr(i) - refTwo.getArr(i);
                newArray.setArr(value, i);
            }
        return newArray;
    }

必要かどうかにかかわらず、ここで私のコンストラクター;

IntArray::IntArray(int size){
    sz = size;
    arr = new int[size];
    for (int i = 0;i < size; i++)
        arr[i] = 0;
}

コピーコンストラクターは使用しませんでした。代わりに、代入演算子を使用しました。そして、私のすべてのコードは次のとおりです。

/*
 * sampleArrayImplemtation.cpp
 *
 *  Created on: Jul 31, 2012
 *      Author: musbuntu
 */

#include <iostream>
#include <cstdlib>
using namespace std;
class IntArray
{
public:
    IntArray(int size);
    //IntArray(const IntArray& ref);
    ~IntArray();
    IntArray& operator= (const IntArray&);
    const int& operator[] (int index) const;
    friend ostream& operator <<(ostream&, IntArray);
    friend istream& operator >>(istream&, IntArray);
    friend IntArray operator *(const IntArray&, const IntArray&);
    friend IntArray operator +(const IntArray&, const IntArray&);
    friend IntArray operator -(const IntArray&, const IntArray&);
    friend bool operator ==(const IntArray&, const IntArray&);
    friend bool operator <(const IntArray&, const IntArray&);
    friend bool operator >(const IntArray&, const IntArray&);
    const int& getArr(const int index) const{
        return arr[index];
    }
    void setArr(int value, int index){
        arr[index] = value;
    }
private:
    int* arr;
    int sz;
};
IntArray& IntArray::operator= (const IntArray& ref){
    if(this!=&ref){
        delete[] arr;
        sz = ref.sz;
        arr = new int[sz];
        for (int i=0; i<sz;i++)
            arr[i] = ref.arr[i];
    }
    return *this;
}
bool operator< (const IntArray& valOne, const IntArray& valTwo){
    int flag(0);
    for(int i = 0;i<valOne.sz;i++)
    {
        if (valOne[i] < valTwo[i]){
            flag = 1;
        }
        else{
            return(0);
        }
    }
    return(flag);
}
bool operator> (const IntArray& valOne, const IntArray& valTwo){
    int flag(0);
    for(int i = 0;i<valOne.sz;i++)
    {
        if (valOne[i] > valTwo[i]){
            flag = 1;
        }
        else{
            return(0);
        }
    }
    return(flag);
}

bool operator== (const IntArray& valOne, const IntArray& valTwo){
    int flag(0);
    for(int i = 0;i<valOne.sz;i++)
    {
        if (valOne[i] == valTwo[i]){
            flag = 1;
        }
        else{
            return(0);
        }
    }
    return(flag);
}
IntArray operator- (const IntArray& refOne, const IntArray& refTwo){
    IntArray newArray(refOne.sz);
    int value;
    for(int i = 0; i < refOne.sz-1; i++){
            value = refOne.getArr(i) - refTwo.getArr(i);
            newArray.setArr(value, i);
        }
    return newArray;
}
IntArray operator+ (const IntArray& refOne, const IntArray& refTwo){
    IntArray newArray(refOne.sz);
    int value;
        for(int i = 0; i < refOne.sz-1; i++){
            value = refOne.getArr(i) + refTwo.getArr(i);
                newArray.setArr(value, i);
            }
    return newArray;
}
IntArray operator* (const IntArray& refOne, const IntArray& refTwo){
    IntArray newArray(refTwo.sz);
    int value;
        for(int i = 0; i < refOne.sz-1; i++){
                value = refOne.getArr(i) * refTwo.getArr(i);
                newArray.setArr(value, i);
            }
    return newArray;
}
istream& operator>> (istream& inputStream, IntArray ref){
    cout << "Enter one by one with respect to a comma> ";
    for(int i = 0; i < ref.sz; i++){
        inputStream >> ref.arr[i];
    }
    return inputStream;
}
ostream& operator<< (ostream& outStream, IntArray ref){
    outStream << "\nYour array has size = " << ref.sz << " and all members are:" << endl;
    for (int i = 0; i < ref.sz; i++){
        outStream << ref[i] << "\t";
    }
    return outStream;
}
const int& IntArray::operator[] (int index) const{
    if (index >= 0 && index < sz){
        return(arr[index]);
    }
    else{
        cerr << "Index out of range, therefore use vectors instead." << endl;
    }
//  return(arr[1]);
}
IntArray::IntArray(int size){
    sz = size;
    arr = new int[size];
    for (int i = 0;i < size; i++)
        arr[i] = 0;
}
//IntArray::IntArray(const IntArray& ref){
//  arr = new int[ref.sz];
//  for(int i=0;i<ref.sz;i++)
//      arr[i] = ref.arr[i];
//}
IntArray::~IntArray(){
    delete[] arr;
}

int main(){
    int sz;
    cout << "Enter size of array> ";
    cin >> sz;
    IntArray arr1(sz);
    arr1.setArr(5, 3);
    IntArray arr2(sz);
    //arr2 = arr1;
    IntArray arr3(sz), arr4(sz), arr5(sz), arr6(sz);
    arr2.setArr(2, 1);
    arr6 = arr1;
    cout << arr6;
    arr3 = arr2 - arr1;
    arr4 = arr1 * arr2;
    arr5 = arr2 + arr1;
    if (arr6 == arr5)
        cout << "It's working.";
    if (arr2 < arr5)
        cout << "It's working, too";
    if (arr4 > arr2)
        cout << "It is also working.";
    cout << arr1 << arr2 << arr3 << arr4 << arr5 << arr6;
    return 0;
}

この問題に対処するために、ディープコピーを使用する必要がありました。そしてこれを行うには; (ウィキペディアの記事によると:)最初にこのライブラリ/ヘッダーを追加します:

#include <algorithm>

そして、ディープコピーコンストラクター:

IntArray(const IntArray& ref):sz(ref.sz), arr(new int[ref.sz]){
    copy(ref.arr, ref.arr + ref.sz, arr);
}

ご辛抱とアドバイスをありがとう...

score 2 · Accepted Answer

3 のルールを尊重します。それ以外の場合は、すべてのバイナリ操作が間違っています。

IntArray operator- (const IntArray& refOne, const IntArray& refTwo){
    IntArray newArray(refOne.sz);
    int value;
    for(int i = 0; i < refOne.sz-1; i++){
            value = refOne.getArr(i) - refTwo.getArr(i);
            newArray.setArr(value, i);
        }
    return newArray;
}

By value を返すIntArrayと、コピーが作成され、コンパイラによって生成されたコピーコンストラクターが使用されます。これを正しく動作させたい場合は、コピーコンストラクターを実装する必要があります。

コメントアウトする代わりに：

public:
   IntArray(int size);
   //IntArray(const IntArray& ref);

プライベートに定義することもできます:

public:
   IntArray(int size);
private:
   //IntArray(const IntArray& ref);

問題はコンパイル時から明らかだったでしょう。

c++ - 割り当てのオーバーロードは明示的にデストラクタを呼び出します (他のバイナリ オーバーロードされた演算子の実行後)

1 に答える 1

Related

Reference

c++ - 割り当てのオーバーロードは明示的にデストラクタを呼び出します (他のバイナリオーバーロードされた演算子の実行後)