由Set作业题引发的问题

Cpp
Cpp
发布日期:   2019-09-05
更新日期:   2024-03-11
文章字数:   1.5k
阅读时长:   6 分
阅读次数:  

问题

c++需要着重学指针，引用和动态内存分配，
这个问题的背后实际上是C++对象的赋值和复制问题，是Set的成员变量所占内存的销毁问题，因为c++的编码逻辑和内存管理交融在一起，所以这种类型的问题难以发现和解决，而且这个坑也经常遇到，现在记录下来给未来防止踩到类似的这种坑。废话不多说，上代码。

Set(Set &s){
        n = s.n;
        if (n !=0)
        {
            pS= new  int[n+1];
            for (int i =1;i<=n;i++) //集合的下标从1开始，集合中不能有重复元素
                pS[i] = s.pS[i];
        }
    }

Set & Set::operator +=(int e){
    if(IsEmpty())
        pS= new  int[101];
    if(!IsElement(e))
        pS[++n]=e;
    return *this;
}    // 向集合中增加元素e

Set Set::operator |(const Set &s)const{
    Set* re=new Set;
    for(int i=1;i<=s.n;i++)
            re+=s.pS[i];

    for(int i=1;i<=n;i++)
        if(!s.IsElement(pS[i]))
            (*re)+=pS[i];    
    return *re;
}  //集合并

所以之前出错的写法 s = s1|s2，就出现了这样的结果：

错误原因

虽然解决方法已经找出来了，就是集合合并的时候返回的是Set的引用即可，但是为什么会发生这种匪夷所思的情况？先上一篇博客康康

C++：对象的赋值和复制

3.6.1 对象赋值语句

如同基本类型赋值语句一样，同类型的对象之间也可以进行赋值，即一个对象的值可以赋给另一个对象。这里所指的对象的赋值是指对其中的数据成员赋值，而不对成员函数赋值。例如：A和B是同一类的两个对象，那么下述对象赋值语句B=A；就能把对象A的数据成员的值逐位复制给对象B

//例3.24 对象赋值语句示例
#include<iostream>
using namespace std;
class Myclass{
 public:
       void set(int i,int j)
       {
        a = i;
        b = j;
       }
       void show(){
        std::cout<< a<<" "<< b;
       } 
 private: 
       int a,b;        
}; 

int main() 
{ 
 Myclass o1,o2; 
 o1.set(20,5); 
 o2 = o1;          //将对象o1的值赋给对象o2 
 o1.show(); 
 o2.show(); 
 return 0;
}

该程序中，语句：
o2 = o1;
等价于语句：
o2.a = o1.a;
o2.b = o1.b;
因此，运行此程序将显示：

说明：
1、在使用对象赋值语句进行对象赋值时，两个对象的类型必须相同，如对象的类型不同，
编译时将出错。
2、两个对象之间的赋值，仅仅使这些对象中数据成员相同，而两个对象仍是分离的。例如
本例对象后，再调用o1.set()设置o1的值，不会影响o2的值。
3、对象赋值是通过默认赋值运算符函数实现的
4、将一个对象的值赋给另一个对象时，多数情况下都是成功的，但当类中存在指针时，可能
会产生错误。

3.6.2 拷贝构造函数

拷贝构造函数是一种特殊的构造函数，其形参是本类对象的引用。拷贝构造函数的作用是，在建立一个新对象时，使用一个已经存在的对象去初始化这个新对象。

例如： Point p2(p1)；

其作用是：在建立新对象p2时，用已经存在的对象p1去初始化对象p2，在这个过程中就要调用拷贝构造函数。
拷贝构造函数具有以下特点：

（1）因为该函数也是一种构造函数，所以其函数名与类名相同，并且该函数也没有返回值类型。

（2）该函数只有一个参数，并且是同类对象的引用

（3）每一个类都必须有一个拷贝构造函数。程序员可以自定义拷贝构造函数，用于按照需要初始化新对象。如果程序员没有定义类的拷贝构造函数，系统就会自动生成产生一个默认的拷贝构造函数，用于复制出数据成员值完全相同的新对象。

  1. 自定义拷贝构造函数
    一般格式： 类名::类名(const 类名 &对象名)
    {
    //拷贝构造函数的函数体
    }
    下面是一个用户自定义的拷贝构造函数：
class Point
{
public:
    Point(int a,int b) //构造函数
    {
    x = a;
    y = b;
    }
    Point(const Point &p) //拷贝构造函数 
    {
    x = 2*p.x;
    y = 2*p.y;
    } 
     .....    
    private:
    {       
    int x;
    int y;
    };

假如p1为类Point的一个对象，则下述语句可以在建立新对象p2时调用拷贝构造函数初始化p2；Point p2(p1);//例3.25 自定义拷贝构造函数的使用。

#include<iostream>
using namespace std;
class Point{
       public:
             Point(int a,int b)  //普通构造函数 
             {
               x = a;
               y = b;
             }
             Point::Point(const Point &p) //自定义的拷贝构造函数 
             {
               x = 2*p.x;
               y = 2*p.y;
             }
             void print()
             {
              cout<<x<<" "<<y<<endl; 
             }
       private:
               int x;
               int y;         
};
int main()
{
 Point p1(30,40);       //定义对象p1，调用了普通的构造函数
 Point p2(p1);          //调用拷贝构造函数，用对象p1初始化对象p2 
 p1.print();
 p2.print();
 return 0; 
}

调用拷贝构造函数的一般形式为：类名 对象2(对象1);上面的这种拷贝构造函数的方法称为“代入法”。除了用代入法调用拷贝构造函数外，还可以采用”赋值法”调用拷贝构造函数,与基本类型的变量初始化类似.这种调用方的一般类名 对象2=对象1;

当然，这种方法可以在一个语句中进行多个对象的复制。如

Point p2=p1,p3=p1; 如将例3.25主函数main改为如下形式：

int main()
{
 Point p1(10,20);
 Point p2=p1;  //以赋值法调用拷贝构造函数 
 p1.print();
 p2.print();
 return 0; 
}
  1. 默认的拷贝构造函数(程序员没有定义，系统会自动生成)

// 例3.26 默认的拷贝构造函数


#include
using namespace std;
class Point{
 public:
        Point(int a,int b) //普通的构造函数 
        {
         x = a;
         y = b;
        }

//        Point::Point(const Point &p)//不用写，系统会默认存在（需要用时直接调用） 
//        {
//         x = p.x;
//         y = p.y;
//        }

        void print()
        {
         cout<

3.6.3调用拷贝构造函数的三种情况

（1）当用类的一个对象去初始化另一个对象时，拷贝构造函数将会被调用，如例3.26主函数中的下属语句
Point p2(p1); //用代入法调用默认的拷贝构造函数,用对象p1初始化对象
p2 Point p3=p1; //用赋值法调用默认的拷贝构造函数,用对象p1初始化对象p3

（2）当函数的形参是类的对象，在调用函数进行形参和实参结合时，拷贝构造函数将会被调用例如：

void fun1(Point p) //形参是类Point的对象p
{   
p.print(); }
int main(){   
point p1(10,20);  
fun1(p1); //调用函数fun1时，实参p1是类Point的对象   
//将调用拷贝构造函数，初始化形参对象p    
return 0; }

理解：在main函数内，执行语句“fun1(p1)”,便是这种情况。在调用这个函数时，对象p1是实参用它来初始化被调用函数的形参p时，需要调用拷贝构造函数。这时，如果类Point中有自定义的拷贝构造函数时，就调用拷贝的构造函数，否则就调用系统自动生成的默认拷贝构造函数

（3）当函数的 返回值是类的对象，在函数调用完毕将返回值（对象）带回调用处时。此时将会调用拷贝构造函数，将此对象赋值给一个临时对象并传到该函数的调用处。
例如： Point fun2() //函数fun2()的返回值类型是Point类类型 {
Point p1(10,30);
//定义类Point的对象p1
return p1; // 函数的返回值是Point类的对象
}
int main(){
Point p2; //定义类Point的对象p1
p2=fun2(); //函数执行完成，返回调用者时，调用拷贝构造函数(赋值法)
return 0;
}

理解：由于对象p1是函数fun2中定义的，在调用函数fun2结束时，p1的生命周期结束了，因此在函数fun2结束之前，执行语句”return p1”时，将会调用拷贝构造函数将p1的值复制到一个临时对象中，这个临时对象是系统在主程序中临时创建的。函数运行结束时，p1对象消失，但是临时对象将会通过语句”p2=fun2()”将它的值赋给对象p2，执行完这个语句后，临时对象变自动消失了。

这里的描述符合我们遇到的这个情况，也就是=赋值，和函数返回时出现的问题，因为按照c++语法，只有用一个新的对象 Class newObj = oldOject 时，才会调用这个类的“拷贝构造函数”，把oldOject 的所有成员变量复制给newObj ，如果是用一个已存在的对象 existObj = oldObject，则不会调用“拷贝构造函数”。
对比 Set tmp = s1|s2 和 s = s1|s2 ，发现主要是函数返回时，前者只销毁了函数内的局部变量re，后者销毁re还销毁了作为返回值的Set对象，这是编译器识别了Set tmp = s1|s2，认为需要替你保留返回值，所以没销毁，而s = s1|s2 这种写法应该本身就是不被语法认可的。
同理，你可以观察(s1|s2).Show() 这种写法，发现返回值是在Show()方法调用后，才被销毁的，所以就能归功到编译器了，是编译器识别了 | 方法被调用的地方的需求，然后对返回值采取了不同的操作。
等学了编译原理，和c++ 的调用惯例就能深刻理解了

赋值

(s1|s2).Show()

最后有两个类似的例子，以供参考

//例3.27  演示调用拷贝构造函数的3中情况

#include<iostream>
using namespace std;
class Point{
  public:
          Point(int a=0,int b=0); //声明构造函数
          Point::Point(const Point &p); //声明拷贝构造函数
        void print()
        {
          cout<<x<<" "<<y<<endl; 
        } 
  private:
        int x,y;
}; 
Point::Point(int a,int b)  //定义构造函数 
{
   x = a;
   y = b;
   cout<<"Using normal constructor\n";
}
Point::Point(const Point &p)//定义拷贝构造函数 
{
   x = 2 * p.x;
   y = 2 * p.y;
   cout<<"Using copy constructor\n"; 
} 
void fun1(Point p)    //形参是类Point的对象p
{
   p.print(); 
}
Point fun2()  //函数fun2()的返回值类型是Point类类型 
{
   Point p4(10,30);  //定义类Point的对象p4 
   return p4;        // 函数的返回值是Point类的对象 
} 
int main()
{
   Point p1(30,40);//定义对象p1时，第1次调用普通的构造函数 
   p1.print();      

   Point p2(p1); //用带入法，用对象p1为对象p2进行初始化。此时会第1次调用拷贝构造函数 
   p2.print();

   Point p3=p1; //用赋值法，用对象p1为对象p3进行初始化。此时会第2次调用拷贝构造函数 
   p3.print();

   fun1(p1);  //在调用fun1函数，实参和形参结合时， 此时会第3次调用拷贝构造函数 

   p2=fun2(); //在调用fun2函数，在函数内部第2次调用普通构造函数。而且，当调用fun2函数结束时,
              //还是用赋值法，用返回的对象p4为对象p2进行赋值，会第4次调用拷贝构造函数 
   p2.print();

   return 0;  
}

运行结果：
Using normal constructor
30 40
Using Cpy constructor
60 80
Using Cpy constructor
60 80
Using Cpy constructor
60 80
Using normal constructor
Using Cpy constructor
20 60

当没有自定义的拷贝构造函数时的运行结果:
Using normal constructor
30 40
30 40
30 40
30 40
Using normal constructor
10 30

再举一个实例

#include<iostream>
using namespace std;
class Point{
  public:
    Point(int a,int b)
     {
       x = a;
       y = b;
     }
     /* Point::*/Point(const Point &p) //拷贝构造函数(用初始化过的对象为没有初始化过的对象进行初始化) 
     {
       x = 2 * p.x;
       y = 2 * p.y;
     }
     Point& operator = (const Point &p)//赋值运算符重载函数(用初始化过的对象为初始化过的对象进行赋值) 
     {
       x = p.x;
       y = p.y;
     }
     Point fun();
     void print()
     {
       cout<<x<<" "<<y<<endl;
     }
   private:
        int x,y;     
};
Point::Point fun(Point p4)
{
    return p4; 
}
int main()
{
  Point p1(10,20);
  Point p3(15,15);

  p3=p1;//调用赋值运算符重载函数 
  p3.print();

  Point p2 = fun(p1);//调用fun函数时，实参和形参结合，会第1次调用拷贝构造函数；调用fun函数结束时，
   p2.print() ;         // 返回的对象p4为未初始化的p2进行初始化，会第2次调用拷贝构造函数 
}

目前已经反馈给教师，等待老师的回答！

文章作者: JoyTsing
文章链接: https://joytsing.github.io/posts/12550/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 JoyTsing !
Cpp
评论
 上一篇
Play-with-Algorithms(1)：O(n^2)排序算法之 选择、插入、冒泡、希尔排序 及 优化 Play-with-Algorithms(1)：O(n^2)排序算法之 选择、插入、冒泡、希尔排序 及 优化
一. 前言1 . 语言要求对于算法而言，它其实是与语言无关的，被誉为算法神书的《算法导论》中都是以伪码的形式进行编写。算法更重要的是一种思想，当你想透彻后编代码实现就不是问题了。由于不同的语言含有独特的特性，在某些语言实现算法过程中可利用其
2019-09-08 Algorithms
Cpp Play-with-Algorithms
下一篇 
贪吃蛇C++教程 贪吃蛇C++教程
概述 整个程序设计的原理就是：主函数死循环，不断刷新打印贪吃蛇和食物。这样每循环一次，就类似电影里面的一帧，最终显示的效果就是蛇会动起来。下面会有一一讲解的,主要涉及到一些类的设计 01初始化工作-游戏设置 游戏设置和相关初始化放在了
2019-08-28 Cpp
Cpp 教程
  目录