1

考虑以下整数的 Binary 类表示的实现：

class Binary {
private:
    int *digits;
    int first1;
public:
    Binary() {
        digits = new int[128];
        digits[0]=0;
        first1=0;
    }
    ~Binary() {
        cout<<"deleting"<<endl;
        delete [] digits;
    }
    Binary(const Binary& b){
        digits = new int[128];
        memcpy(digits,b.digits,128*sizeof(int));
        first1=b.first1;
    }
    explicit Binary(double x){
        int n=(int)x,i;
        digits = new int[128];
        for (i=0; n ; i++,n>>=1) digits[i]=(n & 1)? 1:0;
        first1=i-1;
    }
    Binary& operator =(const Binary& b){
        if (this==&b) return *this;
        memcpy(digits,b.digits,128*sizeof(int));
        first1=b.first1;
        return *this;
    }
    Binary(int n) {
        int i;
        digits = new int[128];
        for (i=0; n ; i++,n>>=1) digits[i]=(n & 1)? 1:0;
        first1=i-1;
    }
    void print() {
        for (int i=first1; i>=0 ; i--) cout<<digits[i];
        cout<<endl;
    }
    operator int() {
        int x = 1,sum=0;
        for (int i=0; i<=first1 ; i++,x<<=1) sum+=digits[i]*x;
        return sum;
    }
    Binary& operator +(Binary& a) {
        int overflow = 0;
        Binary* b1=new Binary();
        int max = a.first1>this->first1? a.first1 : this->first1,bit;
        for (int i=0; i<=max ; i++) {
            bit=a.digits[i]+this->digits[i]+overflow;
            overflow=0;
            if (bit>1) overflow=1;
            b1->digits[i]=bit%2;
        }
        return *b1;
    }

};

和主要使用它：

int main() {
    Binary b(91);
    int x=9;
    Binary *b2=new Binary();
    *b2=b+x;
    x=*b2;
    b2->print();
    cout<<" = "<<x;
    cin>>x;
}

让我们谈谈这条线：

*b2=b+x;

首先编译器为 int x 隐式分配一个新的二进制实例，然后将其用作加法的参数，然后为加法结果创建一个新的二进制实例，并将其逐位复制到 *b2。

问题是，如果您运行此代码，它只会打印删除 ONCE，而为执行命令创建了 2 个对象。显然有一个泄漏来自添加代码，我在其中明确创建了一个新对象来返回结果。

Q1：我说的对吗？

Q2：我能做些什么来克服这个问题？

编辑：可以在此处找到有关运算符重载主题的答案和更多信息

4

3 回答 3

2

摘要：用 分配的对象new必须用 删除delete。用 分配的对象new[]必须用 删除delete[]。全局变量和局部变量在其作用域/TU 执行结束时被自动删除。在Binary& operator +(Binary& a)你制造一个Binary被泄露的，在main你制造另一个Binary被泄露的。

如果这样写，这些问题就可以避免operator+：

Binary operator +(Binary& a) const{ //return by value
    Binary b1(*this); //hold it on the stack
    //math here
    return b1; //return by value
}

如果主要你也避免分配：

Binary b2 = b+x;
x = b2;
b2.print();

这将比您的原始代码更快，更易于阅读和理解，并且不会泄漏。

[其他说明]

将 astd::vector用于内部数据，而不是管理您自己的动态数组。 vector更容易，犯错的可能性也更小。

通常最好尽可能明确地进行转换（如int-> ）。Binary它增加了打字，但省去了麻烦。这也适用于您的int转换运算符。

使您的 const 函数为 const。现在，如果你得到一个const Binary，你几乎不能用它做任何事情。你不能打印它，你不能添加任何东西......

您似乎每存储一位int，这意味着您使用的空间比所需空间多 97%（浪费了 99.99999995% 的值），这很愚蠢。大多数新手都是从0-9per开始的char，这样只会浪费 50% 的空间。（虽然这仍然是 96% 的值），但是真的很容易理解。

加法的正常方法是这样的：

Binary& operator+=(const Binary& rhs) { 
    int max = a.first1>this->first1? a.first1 : this->first1,bit;
    for (int i=0; i<=max ; i++) {
        bit=a.digits[i]+this->digits[i]+overflow;
        overflow=0;
        if (bit>1) overflow=1;
        b1->digits[i]=bit%2;
    }
}  
Binary friend operator+(Binary lhs, const Binary& rhs) {  
{return lhs+=rhs;}
于 2012-07-06T00:39:07.890 回答
0

如果你真的只看到一次“删除”，那么这一定是变量 b。*b2 = b+x可以通过将 b 转换为 int、添加 x、从中构造一个 Binary 并将其复制到 b2 指向的位置来完成。由于 b2 只是一个原始指针，因此您正在泄漏初始 *b2 实例以及覆盖它的实例。

于 2012-07-05T21:59:39.833 回答
0

您不会在 main 末尾删除 b2。

运算符也应该按值返回，而不是返回分配的 Binary 对象，因为这会泄漏，因为 C++ 不是垃圾收集

operator+ 也应该采用 const 引用。

此外，print、operator+ 和 operator int 应该是 const 成员函数

此外，您不需要动态分配 128 个整数，只需将其设为 128 个整数的数组

private:
    int digits[128];

并删除数字上的删除

另外，你应该在构造函数中初始化它

memset(digits, 0, sizeof(digits));
于 2012-07-06T00:59:56.887 回答