1

嗨，我需要访问我班级中的指针成员，用于重载赋值运算符。我的代码如下？请让我做错了什么..感谢它是一个实现复制构造函数、重载赋值运算符、析构函数的简单程序

 #include<iostream>

    class A
    {   
    private:
        int a;
        char *ctr;
        int *itr;
    public:
        A()
        {
            a=10;
            ctr=new char[10];
            itr=NULL;
            cout<<"Inside default constructor"<<endl;
        }
        A(const A &b)
        {
            a=b.a;
            ctr= newchar[10];
            itr=new int;
            *itr=b.*itr;
            *ctr=b.*ctr;
            cout<<"inside copy constructor"<<endl;
        }
        A operator=(const A a)
        {
            A b;
            b.a=a.a;
            b.*itr=a.*itr;
            b.*ctr=a.*ctr;
            cout<<"Overloaded assignment operator"<<endl;

            return b;
        }
        ~A()
        {
          delete(itr);
          delete(ctr);
          cout<<"destructor"<<endl;
        }
     };

int main()
{
    A a1 ,a2;
    a1.*ctr="GOVIND";
    a2.*ctr="SINGH";
    a1.*itr=35;
    a2.*itr=99;
    A a3=a2;
    cout<<"Class template program"<<endl;
    cout<<a1.a<<" ",,a1.*ctr<<" "<<a1.*itr<<endl;
    cout<<a2.a<<" ",,a2.*ctr<<" "<<a2.*itr<<endl;
    cout<<a3.a<<" ",,a3.*ctr<<" "<<a3.*itr<<endl;

    return 0;
}
4

2 回答 2

4 
b.*itr=a.*itr;
b.*ctr=a.*ctr;

应该

*b.itr=*a.itr;
*b.ctr=*a.ctr;

另外，操作员不应该返回对 的引用this吗？

A& operator=(const A a)
{
    this->a = a.a;
    *itr = *a.itr;
    *ctr = *a.ctr;
    return *this;
}
于 2013-08-29T15:36:42.487 回答
1

Sooo 错了，我什至从哪里开始？

首先，智能指针，伙计！智能指针！

    A(const A &b)
    {
        a=b.a;
        ctr= newchar[10];
        itr=new int;
        *itr=b.*itr;

分配值的正确语法是

*itr = *b.itr;

如果你想复制指针，看起来也不同，但是你共享指针并遇到麻烦，所以不要这样做。

无论如何，这仍然是错误的，因为 b.itr 可能为空（您的默认构造函数使其为空）。所以弄清楚你真正想要什么。它永远不应该是非空的吗？在构造函数中分配一些东西。它应该为空吗？然后在复制构造函数中尊重这种可能性。

        *ctr=b.*ctr;

再次错误的语法，但即使你纠正它，它仍然是错误的：它只复制数组中的第一个字符。为什么你这里有这个数组？是固定大小的。你想要一个简单的固定数组吗？你也许想要一个字符串？

        cout<<"inside copy constructor"<<endl;
    }

    A operator=(const A a)

你的意思a是作为参考吗？将 const 值传递给赋值运算符并不是一件好事。如果您正确实现分配，那么非常量值可能是一个好主意。

    {
        A b;

这b应该是什么？您不想使用当前对象吗？

        b.a=a.a;

应该a = a.a;

        b.*itr=a.*itr;

与在复制构造函数中一样，更糟糕的是：如果它已经被分配，你会泄漏旧内存。

        b.*ctr=a.*ctr;

如上所述，同样的新问题。

        cout<<"Overloaded assignment operator"<<endl;

        return b;

复制分配应该返回*this。您正在创建一个悬空引用。如果它没有为此对您大喊大叫，那么您显然还没有将编译器警告调得足够高（或者您忽略了它们）。

    }

    ~A()
    {
      delete(itr);

不要在delete. 嗯，你可以，但这是不寻常的，并且具有误导性。delete不是函数。

      delete(ctr);

ctr被分配了new[]，你必须使用delete[]它来释放它的内存。

      cout<<"destructor"<<endl;
    }

最后一句话：智能指针！

于 2013-08-29T15:48:15.420 回答