多了析构函数就报错

xiang__jie

#include<iostream>
using namespace std;
class  Vector
{
   friend bool operator ==(Vector v1,Vector v2);
   private:
       int len;
       int *p;
   public:
      Vector(int l)
      {
          len=l;
          p=new int[len];
          int i;
          for(i=0;i<len;i++)
             p[i]=(i+1)*i;
      }
      
     int operator [] (int index)
      {
           return p[index];
      }
      ~Vector()
      {
              delete []p;
      }
};

bool  operator ==(Vector v1,Vector v2)
{
     bool ret=true;
     if(v1.len!=v2.len)
          ret=false;
     int i=0;
     while((i<v1.len) &&(v1[i]==v2[i]))
     {
           i++;
     }  
     if(i!=v1.len)
        ret=false;
     return ret;
}

int main()
{
   Vector v1(5),v2(3);
   if(v1==v2)
      cout<<"v1==v2"<<endl;
   else
      cout<<"v1!=v2"<<endl;
   return 0;
}

仰望天上的光

1. #include<iostream>
   
2. using namespace std;
   
3. class Vector;
   
4. bool operator ==( Vector& v1,Vector& v2);
   
5. class  Vector
   
6. {
   
7.    friend bool operator ==( Vector& v1,Vector& v2);
   
8.    private:
   
9.        int len;
   
10.        int *p;
    
11.    public:
    
12.       Vector(int l)
    
13.       {
    
14.           len=l;
    
15.           p=new int[len];
    
16.           int i;
    
17.           for(i=0;i<len;i++)
    
18.              p[i]=(i+1)*i;
    
19.       }
    
20.       
    
21.      int operator [] (int index)
    
22.       {
    
23.            return p[index];
    
24.       }
    
25.       ~Vector()
    
26.       {
    
27.               delete []p;
    
28.       }
    
29. };
    
30. 
    
31. bool  operator ==( Vector& v1,Vector& v2)
    
32. {
    
33.      bool ret=true;
    
34.      if(v1.len!=v2.len)
    
35.           ret=false;
    
36.      int i=0;
    
37.      while((i<v1.len) &&(v1[i]==v2[i]))
    
38.      {
    
39.            i++;
    
40.      }  
    
41.      if(i!=v1.len)
    
42.         ret=false;
    
43.      return ret;
    
44. }
    
45. 
    
46. int main()
    
47. {
    
48.    Vector v1(5),v2(3);
    
49.    if(v1==v2)
    
50.       cout<<"v1==v2"<<endl;
    
51.    else
    
52.       cout<<"v1!=v2"<<endl;
    
53.    return 0;
    
54. }

复制代码

仰望天上的光

你的class Vector有个指针的数据成员int *p;
某人的拷贝构造函数将对这个成员进行“浅复制”，导致两个对象的p成员指向同一个内存块。对象析构时，改内存会被delete[]两次，所以在第2次delete[]的时候报错。
以上程序将operator==的参数改为引用，避免了参数传递时拷贝构造函数的调用，所以不会有问题。但这不是根本的解决之道，根本的解决办法是你要自己实现拷贝构造函数，实现数据p的“深复制”

关于“浅复制”和“深复制”，你可以baidu下它们的意思。

xiang__jie

仰望天上的光 发表于 2012-2-8 22:18

                               
登录/注册后可看大图

你的class Vector有个指针的数据成员int *p;
某人的拷贝构造函数将对这个成员进行“浅复制”，导致两个对象 ...

非常的谢谢，对了，版主，为什么我的贴子有回信为什么我打开主页登陆时没有消息提示，这几天我还以为我的问题一直没有人理呢！

xiang__jie

仰望天上的光 发表于 2012-2-8 22:18

                               
登录/注册后可看大图

你的class Vector有个指针的数据成员int *p;
某人的拷贝构造函数将对这个成员进行“浅复制”，导致两个对象 ...

顺便问一下版主，异常处理中throw抛出 一个对象时，为什么直接用throw 类（）格式，没有一个对象，只有一个类？请帮忙解答

仰望天上的光

xiang__jie 发表于 2012-2-9 22:45

                               
登录/注册后可看大图

顺便问一下版主，异常处理中throw抛出 一个对象时，为什么直接用throw 类（）格式，没有一个对象，只有一 ...

类 对象名（）;以缺省构造函数创建一个名字为“对象名”的对象。

类（）;以缺省构造函数创建一个没有名字的临时对象。
比如你可以写：string()或者vector<int>()都可以得到一个无名的临时对象。
那你也可以先产生一个普通对象，再把它throw出去，如：
MyException  m;
throw m;
和 throw MyEception()效果是一样的。

xiang__jie

仰望天上的光 发表于 2012-2-10 13:40

                               
登录/注册后可看大图

类 对象名（）;以缺省构造函数创建一个名字为“对象名”的对象。

类（）;以缺省构造函数创建一个没有 ...

明白，再谢！

xiang__jie

仰望天上的光 发表于 2012-2-8 22:14

                               
登录/注册后可看大图

#include <iostream>
#include <map>
using namespace std;
class A
{
        private:
        int a;
        public:
        A(int _a):a(_a){}
        bool operator >(A s)
        {
                return (this->a>s.a);
        }
        void show()
        {
                cout<<"a="<<a<<endl;
        }
};
class B
{
        public:
        bool operator () (A a,A b)
        {
                return (a>b);
        }
};
void display(map<A,int,B> s)
{
        map<A,int,B>::iterator it;
        for(it=s.begin();it!=s.end();it++)
        {
                //(it->first).show();
        }
}

int main()
{
        map<A,int,B> c1;
        c1.insert(map<A,int,B>::value_type(A(1),1));
        c1.insert(pair<A,int>(A(2),2));
        display(c1);
        return 0;
}

请版主再帮忙看看

仰望天上的光

1. #include <iostream>
   
2. #include <map>
   
3. using namespace std;
   
4. class A
   
5. {
   
6.         private:
   
7.         int a;
   
8.         public:
   
9.         A(int _a):a(_a){}
   
10.         bool operator >(A s)
    
11.         {
    
12.                 return (this->a>s.a);
    
13.         }
    
14.         void show() const
    
15.         {
    
16.                 cout<<"a="<<a<<endl;
    
17.         }
    
18. };
    
19. class B
    
20. {
    
21.         public:
    
22.         bool operator () (A a,A b)
    
23.         {
    
24.                 return (a>b);
    
25.         }
    
26. };
    
27. void display(map<A,int,B> s)
    
28. {
    
29.         map<A,int,B>::iterator it;
    
30.         for(it=s.begin();it!=s.end();it++)
    
31.         {
    
32.                 (it->first).show();
    
33.         }
    
34. }
    
35. 
    
36. int main()
    
37. {
    
38.         map<A,int,B> c1;
    
39.         c1.insert(map<A,int,B>::value_type(A(1),1));
    
40.         c1.insert(pair<A,int>(A(2),2));
    
41.         display(c1);
    
42.         return 0;
    
43. }

复制代码

把void show()改为void show() const
因为map的键是不可改变的，所以it->first的类型是const A&,因此只能调用const成员函数

此外你自己看看，很多成员函数都可以写为const成员函数，你都没有写，这些函数都存在类似的隐患