第十三章部分课后习题

13.5

/*
给定下面的类框架，编写一个拷贝构造函数，拷贝所有成员。
你的构造函数应该动态分配一个新的string，并将对象拷贝到ps指向的位置，而不是ps本身的位置。
 */

#include<iostream>
#include<string>
using namespace std;

class HasPtr{
public:
    HasPtr(const string &s=string()):ps(new string(s)),i(0){}

    //拷贝构造函数 *hasPtr.ps得到字符串对象
    HasPtr(const HasPtr &hasPtr):ps(new string(*hasPtr.ps)),i(hasPtr.i){}

    //拷贝赋值函数
    HasPtr& operator=(const HasPtr &hasPtr) {
        string *new_ps=new string(*hasPtr.ps);
        delete ps;
        ps=new_ps;
        i=hasPtr.i;
        return *this;
    }

    //析构函数
    ~HasPtr(){
        delete ps;
    }
private:
    string *ps;
    int i;
};

13.13

/* 
定义一个简单的类，为该类定义拷贝构造、赋值函数和析构函数。
编写一个程序以不同方式使用X的对象：将它们作为非引用和引用参数传递；
动态分配它们;将它们存放于容器中。
 */

#include<iostream>
#include <vector>
#include <initializer_list>
using namespace std;


class X{
public:    
    //默认构造函数
    X(){
        cout<<"X()"<<endl;
    }

    //拷贝构造函数
    X(const X&){
        cout<<"X(const &)"<<endl;
    } 

    //拷贝赋值函数
    X& operator=(const X &x){
        cout<<"X& operator=(const X &x)"<<endl;
        return *this;
    }
    //析构函数
    ~X(){
        cout<<"~X()"<<endl;
    }
};

void f(const X &rx, X x)
{
    vector<X> vec;
    vec.reserve(2);
    vec.push_back(rx);
    vec.push_back(x);
}


int main(){
    X x1,x2;
    x1=x2;
    X *px=new X;
    f(*px,x1);
    delete px;
    return 0;
    //输出
    /*  
        X()
        X()
        X& operator=(const X &x)
        X()
        X(const &)
        X(const &)
        X(const &)
        ~X()
        ~X()
        ~X()
        ~X()
        ~X()
        ~X()
     */
}

13.14

/* 
假定numbered是一个类，它有一个默认构造函数，能为每个对象生成一个唯一的序号，
保存在名为mysn的数据成员中。假定numbered使用合成的拷贝控制成员。
 */
#include<iostream>
using namespace std;

class numbered{
friend void f(numbered s);
public:
    numbered(){
        mysn=++cnt;
    }

private:
    int mysn;
    static int cnt; //静态成员变量
};

void f(numbered s){
    cout<<s.mysn<<endl;
}

int numbered::cnt=0;

int main(){
    numbered a,b=a,c=b;
    f(a);
    f(b);
    f(c);
    //输出： 1 1 1
    return 0;
}

13.15

/* 
假定numbered定义了一个拷贝构造函数，能生成一个新的序号。
这会改变上一题中调用的输出结果吗？

答：会
 */
#include<iostream>
using namespace std;

class numbered{
friend void f(numbered s);
public:
    numbered(){
        mysn=++cnt;
    }
    numbered(const numbered &n){
        mysn=++cnt;
    }

private:
    int mysn;
    static int cnt; //静态成员变量
};

void f(numbered s){
    cout<<s.mysn<<endl;
}

int numbered::cnt=0;

int main(){
    numbered a,b=a,c=b;
    f(a);
    f(b);
    f(c);
    //输出: 4 5 6
    return 0;
}

13.16

/* 
若f的参数是const numbered&，将会怎样？这会改变输出结果吗？
若会改变，为什么？新的输出结果是什么?

答：
 */
#include<iostream>
using namespace std;

class numbered{
friend void f(const numbered &s);
public:
    numbered(){
        mysn=++cnt;
    }
    numbered(const numbered &n){
        mysn=++cnt;
    }

private:
    int mysn;
    static int cnt; //静态成员变量
};

void f(const numbered &s){
    cout<<s.mysn<<endl;
}

int numbered::cnt=0;

int main(){
    numbered a,b=a,c=b;
    f(a);
    f(b);
    f(c);
    //输出: 1 2 3 
    return 0;
}

**练习13.33：**为什么Message的成员save和remove的参数是一个Folder&？为什么我们不将参数定义为Folder或者const Folder&?

**答：**save和remove函数传入形参Folder&,是实参的一个副本，因为save函数中需要向原Folder添加指向Message的指针，原Folder需要更改。若传入Folder或const Folder&，原Folder不可以被更改，不符合设计要求。

**练习13.35:**如果Mesage使用合成的拷贝控制成员，将会发生什么？

**答：**合成的拷贝控制成员仅仅复制了contents和folder成员，并没有执行add_to_Folers函数，即没有向folder中每个Folder添加一个指向新生成Message的指针。

**练习13.38：**我们并未使用拷贝和交换方式来设计Message的赋值运算符。

**答：**拷贝和交换在使用动态内存时很好。在Message类中，没有动态内存的情况，如果使用拷贝和交换没什么意义，同时实现起来更加复杂。