C++ primer plus(第六版)编程练习答案第18章探讨新C++标准

浅浅的花香味﹌ 2024-03-24 08:39 106阅读 0赞

## 一、程序清单 ##

## rvref.cpp ##

// rvref.cpp -- simple uses of rvalue references
    #include <iostream>
    
    inline double f(double tf) {return 5.0*(tf-32.0)/9.0;};
    int main()
    {
        using namespace std;
        double tc = 21.5;
        double && rd1 = 7.07;
        double && rd2 = 1.8 * tc + 32.0;
        double && rd3 = f(rd2);
        cout << " tc value and address: " << tc <<", " << &tc << endl;
        cout << "rd1 value and address: " << rd1 <<", " << &rd1 << endl;
        cout << "rd2 value and address: " << rd2 <<", " << &rd2 << endl;
        cout << "rd3 value and address: " << rd3 <<", " << &rd3 << endl;
        // cin.get();
        return 0;
    }

执行结果：

tc value and address: 21.5, 00AFF768
    rd1 value and address: 7.07, 00AFF74C
    rd2 value and address: 70.7, 00AFF730
    rd3 value and address: 21.5, 00AFF714

## useless.cpp ##

// useless.cpp -- an otherwise useless class with move semantics
    #include <iostream>
    using namespace std;
    
    // interface
    class Useless
    {
    private:
        int n;          // number of elements
        char * pc;      // pointer to data
        static int ct;  // number of objects
        void ShowObject() const;
    public:
        Useless();
        explicit Useless(int k);
        Useless(int k, char ch);
        Useless(const Useless & f); // regular copy constructor
        Useless(Useless && f);      // move constructor
        ~Useless();
        Useless operator+(const Useless & f)const;
    // need operator=() in copy and move versions
        void ShowData() const;
    };
    
    // implementation
    int Useless::ct = 0;
    
    Useless::Useless()
    {
        ++ct;
        n = 0;
        pc = nullptr;
        cout << "default constructor called; number of objects: " << ct << endl;
        ShowObject();
    }
    
    Useless::Useless(int k) : n(k)
    {
        ++ct; 
        cout << "int constructor called; number of objects: " << ct << endl;
        pc = new char[n];
        ShowObject();
    }
    
    Useless::Useless(int k, char ch) : n(k)
    {
        ++ct;
        cout << "int, char constructor called; number of objects: " << ct << endl;
        pc = new char[n];
        for (int i = 0; i < n; i++)
            pc[i] = ch;
        ShowObject();
    }
    
    Useless::Useless(const Useless & f): n(f.n) 
    {
        ++ct;
        cout << "copy const called; number of objects: " << ct << endl;
        pc = new char[n];
        for (int i = 0; i < n; i++)
            pc[i] = f.pc[i];
        ShowObject();
    }
    
    Useless::Useless(Useless && f): n(f.n) 
    {
        ++ct;
        cout << "move constructor called; number of objects: " << ct << endl;
        pc = f.pc;       // steal address
        f.pc = nullptr;  // give old object nothing in return
        f.n = 0;
        ShowObject();
    }
    
    Useless::~Useless()
    {
        cout << "destructor called; objects left: " << --ct << endl;
        cout << "deleted object:\n";
        ShowObject();
        delete [] pc;
    }
    
    Useless Useless::operator+(const Useless & f)const
    {
        cout << "Entering operator+()\n";
        Useless temp = Useless(n + f.n);
        for (int i = 0; i < n; i++)
            temp.pc[i] = pc[i];
        for (int i = n; i < temp.n; i++)
            temp.pc[i] = f.pc[i - n];
        cout << "temp object:\n";
        cout << "Leaving operator+()\n";
        return temp;
    }
    
    void Useless::ShowObject() const
    { 
        cout << "Number of elements: " << n;
        cout << " Data address: " << (void *) pc << endl;
    }
    
    void Useless::ShowData() const
    {
        if (n == 0)
            cout << "(object empty)";
        else
            for (int i = 0; i < n; i++)
                cout << pc[i];
        cout << endl;
    }
    
    // application
    int main()
    {
        {
            Useless one(10, 'x');
            Useless two = one;          // calls copy constructor
            Useless three(20, 'o');
            Useless four(one + three);  // calls operator+(), move constructor
            cout << "object one: ";
            one.ShowData();
            cout << "object two: ";
            two.ShowData();
            cout << "object three: ";
            three.ShowData();
            cout << "object four: ";
            four.ShowData();
        }
        // cin.get();
    }

执行结果：

int, char constructor called; number of objects: 1
    Number of elements: 10 Data address: 00A46038
    copy const called; number of objects: 2
    Number of elements: 10 Data address: 00A45EB0
    int, char constructor called; number of objects: 3
    Number of elements: 20 Data address: 00A49380
    Entering operator+()
    int constructor called; number of objects: 4
    Number of elements: 30 Data address: 00A4CEC8
    temp object:
    Leaving operator+()
    move constructor called; number of objects: 5
    Number of elements: 30 Data address: 00A4CEC8
    destructor called; objects left: 4
    deleted object:
    Number of elements: 0 Data address: 00000000
    object one: xxxxxxxxxx
    object two: xxxxxxxxxx
    object three: oooooooooooooooooooo
    object four: xxxxxxxxxxoooooooooooooooooooo
    destructor called; objects left: 3
    deleted object:
    Number of elements: 30 Data address: 00A4CEC8
    destructor called; objects left: 2
    deleted object:
    Number of elements: 20 Data address: 00A49380
    destructor called; objects left: 1
    deleted object:
    Number of elements: 10 Data address: 00A45EB0
    destructor called; objects left: 0
    deleted object:
    Number of elements: 10 Data address: 00A46038

## stdmove.cpp ##

// stdmove.cpp -- using std::move()
    #include <iostream>
    #include <utility>
    // use the following for g++4.5
    // #define nullptr 0
    // interface
    class Useless
    {
    private:
        int n;          // number of elements
        char * pc;      // pointer to data
        static int ct;  // number of objects
        void ShowObject() const;
    public:
        Useless();
        explicit Useless(int k);
        Useless(int k, char ch);
        Useless(const Useless & f); // regular copy constructor
        Useless(Useless && f);      // move constructor
        ~Useless();
        Useless operator+(const Useless & f)const;
        Useless & operator=(const Useless & f); // copy assignment
        Useless & operator=(Useless && f);      // move assignment 
        void ShowData() const;
    };
    
    // implementation
    int Useless::ct = 0;
    
    Useless::Useless()
    {
        ++ct;
        n = 0;
        pc = nullptr;
     }
    
    Useless::Useless(int k) : n(k)
    {
        ++ct; 
        pc = new char[n];
    }
    
    Useless::Useless(int k, char ch) : n(k)
    {
        ++ct;
        pc = new char[n];
        for (int i = 0; i < n; i++)
            pc[i] = ch;
    }
    
    Useless::Useless(const Useless & f): n(f.n) 
    {
        ++ct;
        pc = new char[n];
        for (int i = 0; i < n; i++)
            pc[i] = f.pc[i];
    }
    
    Useless::Useless(Useless && f): n(f.n) 
    {
        ++ct;
        pc = f.pc;       // steal address
        f.pc = nullptr;  // give old object nothing in return
        f.n = 0;
    }
    
    Useless::~Useless()
    {
        delete [] pc;
    }
    
    Useless & Useless::operator=(const Useless & f)  // copy assignment
    {
        std::cout << "copy assignment operator called:\n";
        if (this == &f)
            return *this;
        delete [] pc;
        n = f.n;
        pc = new char[n];
        for (int i = 0; i < n; i++)
            pc[i] = f.pc[i];
        return *this;
    }
    
    Useless & Useless::operator=(Useless && f)       // move assignment
    {
        std::cout << "move assignment operator called:\n";
        if (this == &f)
            return *this;
        delete [] pc;
        n = f.n;
        pc = f.pc;
        f.n = 0;
        f.pc = nullptr;
        return *this;
    }
    
    Useless Useless::operator+(const Useless & f)const
    {
        Useless temp = Useless(n + f.n);
        for (int i = 0; i < n; i++)
            temp.pc[i] = pc[i];
        for (int i = n; i < temp.n; i++)
            temp.pc[i] = f.pc[i - n];
        return temp;
    }
    
    void Useless::ShowObject() const
    { 
        std::cout << "Number of elements: " << n;
        std::cout << " Data address: " << (void *) pc << std::endl;
    }
    
    void Useless::ShowData() const
    {
        if (n == 0)
            std::cout << "(object empty)";
        else
            for (int i = 0; i < n; i++)
                std::cout << pc[i];
        std::cout << std::endl;
    }
    
    // application
    int main()
    {
        using std::cout;
        {
            Useless one(10, 'x');
            Useless two = one +one;   // calls move constructor
            cout << "object one: ";
            one.ShowData();
            cout << "object two: ";
            two.ShowData();
            Useless three, four;
            cout << "three = one\n";
            three = one;              // automatic copy assignment
            cout << "now object three = ";
            three.ShowData();
            cout << "and object one = ";
            one.ShowData();
            cout << "four = one + two\n";
            four = one + two;         // automatic move assignment
            cout << "now object four = ";
            four.ShowData();
            cout << "four = move(one)\n";
            four = std::move(one);    // forced move assignment
            cout << "now object four = ";
            four.ShowData();
            cout << "and object one = ";
            one.ShowData();
        }
         std::cin.get();
    }

执行结果：

object one: xxxxxxxxxx
    object two: xxxxxxxxxxxxxxxxxxxx
    three = one
    copy assignment operator called:
    now object three = xxxxxxxxxx
    and object one = xxxxxxxxxx
    four = one + two
    move assignment operator called:
    now object four = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    four = move(one)
    move assignment operator called:
    now object four = xxxxxxxxxx
    and object one = (object empty)

## lambda0.cpp ##

// lambda0.cpp -- using lambda expressions
    #include <iostream>
    #include <vector>
    #include <algorithm>
    #include <cmath>
    #include <ctime>
    const long Size1 = 39L;
    const long Size2 = 100*Size1;
    const long Size3 = 100*Size2;
    
    bool f3(int x) {return x % 3 == 0;}
    bool f13(int x) {return x % 13 == 0;}
    
    int main()
    {
        using std::cout;
        std::vector<int> numbers(Size1);
    
        std::srand(std::time(0));
        std::generate(numbers.begin(), numbers.end(), std::rand);
    
    // using function pointers
        cout << "Sample size = " << Size1 << '\n';
    
        int count3 = std::count_if(numbers.begin(), numbers.end(), f3);
        cout << "Count of numbers divisible by 3: " << count3 << '\n';
        int count13 = std::count_if(numbers.begin(), numbers.end(), f13);
        cout << "Count of numbers divisible by 13: " << count13 << "\n\n";
    
    // increase number of numbers
        numbers.resize(Size2);
        std::generate(numbers.begin(), numbers.end(), std::rand);
        cout << "Sample size = " << Size2 << '\n';
    // using a functor
        class f_mod
        {
        private:
            int dv;
        public:
            f_mod(int d = 1) : dv(d) {}
            bool operator()(int x) {return x % dv == 0;}
        };
    
        count3 = std::count_if(numbers.begin(), numbers.end(), f_mod(3));
        cout << "Count of numbers divisible by 3: " << count3 << '\n';
        count13 = std::count_if(numbers.begin(), numbers.end(), f_mod(13));
        cout << "Count of numbers divisible by 13: " << count13 << "\n\n";
    
    // increase number of numbers again
        numbers.resize(Size3);
        std::generate(numbers.begin(), numbers.end(), std::rand);
        cout << "Sample size = " << Size3 << '\n';
    // using lambdas
        count3 = std::count_if(numbers.begin(), numbers.end(),
                 [](int x){return x % 3 == 0;});
        cout << "Count of numbers divisible by 3: " << count3 << '\n';
        count13 = std::count_if(numbers.begin(), numbers.end(),
                  [](int x){return x % 13 == 0;});
        cout << "Count of numbers divisible by 13: " << count13 << '\n';
    
        // std::cin.get();
        return 0;
    }

执行结果:

Sample size = 39
    Count of numbers divisible by 3: 15
    Count of numbers divisible by 13: 0
    
    Sample size = 3900
    Count of numbers divisible by 3: 1283
    Count of numbers divisible by 13: 275
    
    Sample size = 390000
    Count of numbers divisible by 3: 130022
    Count of numbers divisible by 13: 29969

## lambda1.cpp ##

// lambda1.cpp -- use captured variables
    #include <iostream>
    #include <vector>
    #include <algorithm>
    #include <cmath>
    #include <ctime>
    const long Size = 390000L;
    
    int main()
    {
        using std::cout;
        std::vector<int> numbers(Size);
    
        std::srand(std::time(0));
        std::generate(numbers.begin(), numbers.end(), std::rand);
        cout << "Sample size = " << Size << '\n';
    // using lambdas
        int count3 = std::count_if(numbers.begin(), numbers.end(), 
    		      [](int x){return x % 3 == 0;});
        cout << "Count of numbers divisible by 3: " << count3 << '\n';
        int count13 = 0;
        std::for_each(numbers.begin(), numbers.end(),
             [&count13](int x){count13 += x % 13 == 0;});
        cout << "Count of numbers divisible by 13: " << count13 << '\n';
    // using a single lambda
        count3 = count13 = 0;
        std::for_each(numbers.begin(), numbers.end(),
             [&](int x){count3 += x % 3 == 0; count13 += x % 13 == 0;});
        cout << "Count of numbers divisible by 3: " << count3 << '\n';
        cout << "Count of numbers divisible by 13: " << count13 << '\n';
    
        // std::cin.get();
        return 0;
    }

执行结果：

Sample size = 390000
    Count of numbers divisible by 3: 129765
    Count of numbers divisible by 13: 30268
    Count of numbers divisible by 3: 129765
    Count of numbers divisible by 13: 30268

## somedefs.h ##

// somedefs.h
    #include <iostream>
    
    template <typename T, typename F>
      T use_f(T v, F f)
      {
          static int count = 0;
          count++;
          std::cout << "use_f count = " << count
    		        << ", &count = " << &count << endl;
          return f(v);
      }
    
      class Fp
      {
      private:
          double z_;
      public:
          Fp(double z = 1.0) : z_(z) {}
          double operator()(double p) { return z_*p; }
      };
    
      class Fq
      {
      private:
          double z_;
      public:
          Fq(double z = 1.0) : z_(z) {}
          double operator()(double q) { return z_+ q; }
      };·

## callable.cpp ##

// callable.cpp -- callable types and templates
    #include <iostream>
    #include"somedefs.h"
    using namespace std;
    
    double dub(double x) { return 2.0 * x; }
    double square(double x) { return x * x; }
    
    int main()
    {
    	double y = 1.21;
    	cout << "Function pointer dub:\n";
    	cout << "  " << use_f(y, dub) << endl;
    	cout << "Function pointer sqrt:\n";
    	cout << "  " << use_f(y, square) << endl;
    	cout << "Function object Fp:\n";
    	cout << "  " << use_f(y, Fp(5.0)) << endl;
    	cout << "Function object Fq:\n";
    	cout << "  " << use_f(y, Fq(5.0)) << endl;
    	cout << "Lambda expression 1:\n";
    	cout << "  " << use_f(y, [](double u) {return u * u; }) << endl;
    	cout << "Lambda expresson 2:\n";
    	cout << "  " << use_f(y, [](double u) {return u + u / 2.0; }) << endl;
    
    	cin.get();
    	return 0;
    }

执行结果：

Function pointer dub:
    use_f count = 1,count = 0010C140
      2.42
    Function pointer sqrt:
    use_f count = 2,count = 0010C140
      1.4641
    Function object Fp:
    use_f count = 1,count = 0010C144
      6.05
    Function object Fq:
    use_f count = 1,count = 0010C148
      6.21
    Lambda expression 1:
    use_f count = 1,count = 0010C14C
      1.4641
    Lambda expresson 2:
    use_f count = 1,count = 0010C150
      1.815

## wrapped0.cpp ##

// wrapped0.cpp  -- using a function wrapper
    #include "somedefs.h"
    #include <iostream>
    #include <math.h>
    #include <functional>
    
    double dub(double x) { return 2.0 * x; }
    double sqaure(double x) { return x * x; }
    int main()
    {
    	using std::cout;
    	using std::endl;
    	using std::function;
    	typedef function<double(double)> fdd;
    	double y = 1.21;
    	function<double(double)> ef1 = dub;
    	function<double(double)> ef2 = sqaure;
    	function<double(double)> ef3 = Fq(10.0);
    	function<double(double)> ef4 = Fp(10.0);
    	function<double(double)> ef5 = [](double u) {return u * u; };
    	function<double(double)> ef6 = [](double u) {return u + u / 2.0; };
    	cout << use_f(y, function<double(double)>(dub)) << endl;
    	cout << use_f(y, fdd(sqaure)) << endl;
    	cout << use_f(y, ef3) << endl;
    	cout << use_f(y, ef4) << endl;
    	cout << use_f(y, ef5) << endl;
    	cout << use_f(y, ef6) << endl;
    
    	std::cin.get();
    	return 0;
    }

执行结果:

use_f count = 1,count = 00A834E0
    2.42
    use_f count = 2,count = 00A834E0
    1.4641
    use_f count = 3,count = 00A834E0
    11.21
    use_f count = 4,count = 00A834E0
    12.1
    use_f count = 5,count = 00A834E0
    1.4641
    use_f count = 6,count = 00A834E0
    1.815

## wrapped2.cpp ##

//wrapped1.cpp -- using a function wrapper as an argument
    #include <iostream>
    #include <math.h>
    #include <functional>
    #include"somedefs.h"
    using namespace std;
    
    
    double dub(double x) { return 2.0 * x; }
    double sqaure(double x) { return x * x; }
    
    int main()
    {
    	double y = 1.21;
    	function<double(double)> ef1 = dub;
    	function<double(double)> ef2 = sqaure;
    	function<double(double)> ef3 = Fq(10.0);
    	function<double(double)> ef4 = Fp(10.0);
    	function<double(double)> ef5 = [](double u) {return u * u; };
    	function<double(double)> ef6 = [](double u) {return u + u / 2.0; };
    	cout << "Function pointer dub:\n";
    	cout << "  " << use_f(y, ef1) << endl;
    	cout << "Function pointer sqrt:\n";
    	cout << "  " << use_f(y, ef2) << endl;
    	cout << "Function object Fp:\n";
    	cout << "  " << use_f(y, ef3) << endl;
    	cout << "Function object Fq:\n";
    	cout << "  " << use_f(y, ef4) << endl;
    	cout << "Lambda expression 1:\n";
    	cout << "  " << use_f(y, ef5) << endl;
    	cout << "Lambda expression 2:\n";
    	cout << "  " << use_f(y, ef6) << endl;
    	// cin.get();
    	return 0;
    }

执行结果:

Function pointer dub:
    use_f count = 1,count = 00D134E0
      2.42
    Function pointer sqrt:
    use_f count = 2,count = 00D134E0
      1.4641
    Function object Fp:
    use_f count = 3,count = 00D134E0
      11.21
    Function object Fq:
    use_f count = 4,count = 00D134E0
      12.1
    Lambda expression 1:
    use_f count = 5,count = 00D134E0
      1.4641
    Lambda expression 2:
    use_f count = 6,count = 00D134E0
      1.815

wrapped2.cpp

// wrapped2.cpp -- callable types and templates
    #include <iostream>
    #include <math.h>
    #include <functional>
    #include"somedefs.h"
    using namespace std;
    
    double dub(double x) { return 2.0 * x; }
    double sqaure(double x) { return x * x; }
    
    int main()
    {
    	double y = 1.21;
    	cout << "Function pointer dub:\n";
    	cout << "  " << use_f<double>(y, dub) << endl;
    	cout << "Function pointer sqrt:\n";
    	cout << "  " << use_f<double>(y, sqaure) << endl;
    	cout << "Function object Fp:\n";
    	cout << "  " << use_f<double>(y, Fp(5.0)) << endl;
    	cout << "Function object Fq:\n";
    	cout << "  " << use_f<double>(y, Fq(5.0)) << endl;
    	cout << "Lambda expression 1:\n";
    	cout << "  " << use_f<double>(y, [](double u) {return u * u; }) << endl;
    	cout << "Lambda expression 2:\n";
    	cout << "  " << use_f<double>(y, [](double u) {return u + u / 2.0; }) << endl;
    
    	cin.get();
    	return 0;
    }

执行结果：

Function pointer dub:
    use_f count = 1,count = 008F34E0
      2.42
    Function pointer sqrt:
    use_f count = 2,count = 008F34E0
      1.4641
    Function object Fp:
    use_f count = 1,count = 008F34F0
      6.05
    Function object Fq:
    use_f count = 1,count = 008F34F4
      6.21
    Lambda expression 1:
    use_f count = 1,count = 008F3814
      1.4641
    Lambda expression 2:
    use_f count = 1,count = 008F3818
      1.815

## variadic1.cpp ##

//variadic1.cpp -- using recursion to unpack a parameter pack
    #include <iostream>
    #include <string>
    // definition for 0 parameters -- terminating call
    void show_list3() {}
    
    // definition for 1 or more parameters
    template<typename T, typename... Args>
    void show_list3(T value, Args... args)
    {
    	std::cout << value << ", ";
    	show_list3(args...);
    }
    
    int main()
    {
    	int n = 14;
    	double x = 2.71828;
    	std::string mr = "Mr. String objects!";
    	show_list3(n, x);
    	show_list3(x*x, '!', 7, mr);
    	return 0;
    }

执行结果：

14, 2.71828, 7.38905, !, 7, Mr. String objects!,

## variadic2.cpp ##

// variadic2.cpp
    #include <iostream>
    #include <string>
    
    // definition for 0 parameters
    void show_list() {}
    
    // definition for 1 parameter
    template<typename T>
    void show_list(const T& value)
    {
        std::cout << value << '\n';
    }
    
    // definition for 2 or more parameters
    template<typename T, typename... Args>
    void show_list(const T& value, const Args&... args)
    {
        std::cout << value << ", ";
        show_list(args...); 
    }
    
    int main()
    {
        int n = 14;
        double x = 2.71828;
        std::string mr = "Mr. String objects!";
        show_list(n, x);
        show_list(x*x, '!', 7, mr);
        return 0;
    }

执行结果：

14, 2.71828
    7.38905, !, 7, Mr. String objects!

## **lexcast.cpp**  ##

// lexcast.cpp -- simple cast from float to string
    #include <iostream>
    #include <string>
    #include "boost/lexical_cast.hpp"
    int main()
    {
    	using namespace std;
    	cout << "Enter your weight: ";
    	float weight;
    	cin >> weight;
    	string gain = "A 10% increase raises ";
    	string wt = boost::lexical_cast<string>(weight);
    	gain = gain + wt + " to ";  // string operator+()
    	weight = 1.1 * weight;
    	gain = gain + boost::lexical_cast<string>(weight) + ".";
    	cout << gain << endl;
    	return 0;
    }

> **执行需要安装boost库**

## 二、复习题 ##

**1. 使用用大括号括起的初始化列表语法重写下述代码。重写后的代码不应使用数组ar：**

>     class Z200
>     {
>         private:
>         int j;
>         char ch;
>         double z;
>         public:
>         Z200(int jv, char chv, zv) : j(jv), ch(chv), z(zv) {}
>         ...
>     };
>     double x = 8.8;
>     std::string s = "What a bracing effect!";
>     int k(99);
>     Z200 zip(200,'Z',0.675);
>     std::vector<int> ai(5);
>     int ar[5] = {3, 9, 4, 7, 1};
>     for (auto pt = ai.begin(), int i = 0; pt != ai.end(); ++pt, ++i)
>         *pt = ai[i];

重写后代码：

class Z200
    {
        private:
        int j;
        char ch;
        double z;
        public:
        Z200(int jv, char chv, zv) : j(jv), ch(chv), z(zv) {}
        ...
    };
    double x{8.8}; // = {8.8}
    std::string s{"What a bracing effect!"};
    int k{99};
    Z200 zip{200,'Z',0.675};
    std::vector<int> ai{3, 9, 4, 7, 1};

**2.2. 在下述简短的程序中，哪些函数调用不对？为什么？对于合法的函数调用，指出其引用参数指向的是什么。**

>     #include <iostream>
>     using namespace std;
>     double up(double x) { return 2.0* x;}
>     void r1(const double &rx) {cout << rx << endl;}
>     void r2(double &rx) {cout << rx << endl;}
>     void r3(double &&rx) {cout << rx << endl;}
>     int main()
>     {
>         double w = 10.0;
>         r1(w);
>         r1(w+1);
>         r1(up(w));
>         r2(w);
>         r2(w+1);
>         r2(up(w));
>         r3(w);
>         r3(w+1);
>         r3(up(w));
>         return 0;
>     }

*  `r1(w);` \----合法，形参`rx`指向`w`。
 *  `r1(w+1);`\----合法，形参`rx`指向一个临时变量，这个变量被初始化为`w+1`。
 *  `r1(up(w));`\---合法，形参`rx`指向一个临时变量，这个变量被初始化为`up(w)`的返回值。
 *  `r2(w);`\---合法，形参`rx`指向`w`。
 *  `r2(w+1)`; ---非法，因为`w+1`是一个右值。
 *  `r2(up(w));`\---非法，因为`up(w)`的返回值是一个右值。
 *  `r3(w);`\---非法，因为右值引用不能指向左值（如`w`）。
 *  `r3(w+1);`\---合法，`rx`指向表达式`w+1`的临时拷贝。
 *  `r3(up(w));`\---合法，`rx`指向`up(w)`的临时返回值。

一般而言，将左值传递给`const`左值引用参数的时候，参数将被初始化为左值。将右值传递给函数时，`const`左值引用参数将指向右值的临时拷贝。将左值传递给非`const`左值引用参数时，参数将被初始化为左值；但非`const`左值形参不能接受右值实参。

**3. a. 下述简短的程序显示什么？为什么？**

>     #include <iostream>
>     using namespace std;
>     double up(double x) { return 2.0 * x; }
>     void r1(const double &rx) { cout << "const double & rx\n"; }
>     void r1(double &rx) { cout << "double & rx\n"; }
>     int main() {
>         double w = 10.0;
>         r1(w);
>         r1(w + 1);
>         r1(up(w));
>         return 0;
>     }

**b. 下述简短的程序显示什么？为什么？**

>     #include <iostream>
>     using namespace std;
>     double up(double x) { return 2.0 * x; }
>     void r1(double &rx) { cout << "double & rx\n"; }
>     void r1(double &&rx) { cout << "double && rx\n"; }
>     int main() {
>         double w = 10.0;
>         r1(w);
>         r1(w + 1);
>         r1(up(w));
>         return 0;
>     }

**c. 下述简短的程序显示什么？为什么？**

>     #include <iostream>
>     using namespace std;
>     double up(double x) { return 2.0 * x; }
>     void r1(const double &rx) { cout << "const double & rx\n"; }
>     void r1(double &&rx) { cout << "double && rx\n"; }
>     int main() {
>         double w = 10.0;
>         r1(w);
>         r1(w + 1);
>         r1(up(w));
>         return 0;
>     }

double & rx
    const double & rx
    const double & rx

非`const`左值引用与左值实参匹配，因此`r1(w);`调用`void r1(double &rx)`。另外两个实参均为右值，const左值引用可以指向他们的拷贝。【将右值传递给函数时，`const`左值引用参数将指向右值的临时拷贝。】。

double & rx
    double && rx
    double && rx

左值引用与左值实参`w`匹配，而右值引用与两个右值实参匹配。

const double & rx
    double && rx
    double && rx

`const`左值引用与左值实参`w`匹配，而右值引用与两个右值实参匹配。

总之，非`const`左值形参与左值实参匹配，非`cosnt`右值形参与右值实参匹配；`const`左值形参可以与左值或右值实参匹配。如果可供选择的话，编译器优先选择前两种方式。

**4. 哪些成员函数是特殊的成员函数？它们特殊的原因是什么？**

特殊成员函数：默认构造函数、复制构造函数、移动构造函数、析构函数、复制赋值运算符和移动赋值运算符。这些函数之所以特殊，是因为编译器将根据情况自动提供它们的默认版本。

**5. 假设Fizzle类只有如下所示的数据成员：**

>     class Fizzle
>     {
>         private:
>         double bubbles[4000];
>         ...
>     };

**为什么不适合给这个类定义移动构造函数？要让这个类适合定义移动构造函数，应如何修改存储4000个double值的方式？**

移动构造函数是在转让数据所有权可行的时候是合适的。但对于标准数组没有转让所有权的机制，因此不适合给该类定义移动构造函数。如果`Fizzle`使用指针和动态内存分配来存储这4000个`double`值，即可以将数据的地址赋给新指针，以转让其所有权，则适合给`Fizzle`定义移动构造函数。

**6. 修改下述简短的程序，使其使用lambda表达式而不是f1( )。请不要修改show2( )。**

>     #include <iostream>
>     template<typename T>
>     void show2(double x, T& fp) {std::cout << x << " -> " << fp(x) << '\n';}
>     double f1(double x) { return 1.8*x + 32;}
>     int main()
>     {
>         show2(18.0, f1);
>         return 0;
>     }

修改后：

#include <iostream>
    template <typename T>
    void show2(double x, T& fp) { std::cout << x << " -> " << fp(x) << '\n';}
    //void show2(double x, T fp) {std::cout << x << " -> " << fp(x) << '\n';}
    int main() {
        auto f2 = [](double x) { return 1.8 * x + 32; };
        show2(18.0, f2);
        //show2(18.0, [](double x){return 1.8*x + 32;});
        return 0;
    }

**7. 修改下述简短而丑陋的程序，使其使用lambda表达式而不是函数符Adder。请不要修改sum( )。**

>     #include <iostream>
>     #include <array>
>     const int Size = 5;
>     template<typename T>
>     void sum(std::array<double,Size> a, T& fp);
>     class Adder
>     {
>         double tot;
>         public:
>         Adder(double q = 0) : tot(q) {}
>         void operator()(double w) { tot +=w;}
>         double tot_v () const {return tot;};
>     };
>     int main()
>     {
>         double total = 0.0;
>         Adder ad(total);
>         std::array<double, Size> temp_c = {32.1, 34.3, 37.8, 35.2, 34.7};
>         sum(temp_c,ad);
>         total = ad.tot_v();
>         std::cout << "total: " << ad.tot_v() << '\n';
>         return 0;
>     }
>     template<typename T>
>     void sum(std::array<double,Size> a, T& fp)
>     {
>         for(auto pt = a.begin(); pt != a.end(); ++pt)
>         {
>             fp(*pt);
>         }
>     }

修改后：

#include <array>
    #include <iostream>
    const int Size = 5;
    template <typename T>
    void sum(std::array<double, Size> a, T& fp);
    
    int main() {
        double total = 0.0;
        std::array<double, Size> temp_c = {32.1, 34.3, 37.8, 35.2, 34.7};
        auto f = [&total](double x) { total += x; };
        sum(temp_c, f);
        std::cout << "total: " << total << '\n';
        return 0;
    }
    template <typename T>
    void sum(std::array<double, Size> a, T& fp) {
        for (auto pt = a.begin(); pt != a.end(); ++pt) {
            fp(*pt);
        }
    }

## 三、编程练习 ##

**1. 下面是一个简短程序的一部分：**

>     int main()
>     {
>         using namespace std;
>         // list of double deduced from list contents
>         auto q = average_list({15.4, 10.7, 9.0});
>         cout << q << endl;
>         // list of int deduced from list contents
>         cout << average_list({20, 30, 19, 17, 45, 38} ) << endl;
>         // forced list of double
>         auto ad = average_list<double>({'A', 70, 65.33});
>         cout << ad << endl;
>         return 0;
>     }

**请提供函数average\_list( )，让该程序变得完整。它应该是一个模板函数，其中的类型参数指定了用作函数参数的initilize\_list模板的类型以及函数的返回类型。**

修改后：

#include <algorithm>
    #include <initializer_list>
    #include <iostream>
    using namespace std;
    
    template <typename T>
    T average_list(initializer_list<T> l) {
        T sum = 0;
        if (l.size() == 0) return 0;
        for_each(l.begin(), l.end(), [&sum](T t) { sum += t; });
        return sum / l.size();
    }
    
    int main() {
        using namespace std;
        // list of double deduced from list contents
        auto q = average_list({15.4, 10.7, 9.0});
        cout << q << endl;
        // list of int deduced from list contents
        cout << average_list({20, 30, 19, 17, 45, 38}) << endl;
        // forced list of double
        auto ad = average_list<double>({'A', 70, 65.33});
        cout << ad << endl;
        return 0;
    }

**2. 下面是类Cpmv的声明：**

>     class Cpmv
>     {
>         public:
>         struct Info
>         {
>             std::string qcode;
>             std::string zcode;
>         };
>         private:
>         Info *pi;
>         public:
>         Cpmv();
>         Cpmv(std::string q, std::string z);
>         Cpmv(const Cpmv & cp);
>         Cpmv(Cpmv && mv);
>         ~Cpmv();
>         Cpmv & operator=(const Cpmv & cp);
>         Cpmv & operator=(Cpmv && mv);
>         Cpmv operator+(const Cpmv & obj) const;
>         void Display() const;
>     };

**函数operator+ ( )应创建一个对象，其成员qcode和zcode有操作数的相应成员拼接而成。请提供为移动构造函数和移动赋值运算符实现移动语义的代码。编写一个使用所有这些方法的程序。为方便测试，让各个方法都显示特定的内容，以便知道它们被调用。**

代码如下：

#include <iostream>
    
    using namespace std;
    
    class Cpmv {
        public:
        struct Info {
            std::string qcode;
            std::string zcode;
        };
    
        private:
        Info *pi;
    
        public:
        Cpmv();
        Cpmv(std::string q, std::string z);
        Cpmv(const Cpmv &cp);
        Cpmv(Cpmv &&mv);
        ~Cpmv();
        Cpmv &operator=(const Cpmv &cp);
        Cpmv &operator=(Cpmv &&mv);
        Cpmv operator+(const Cpmv &obj) const;
        void Display() const;
    };
    
    int main() {
        Cpmv c1;
        Cpmv c2("abc", "123");
        Cpmv c3(c2);
        c1 = c2;
        c1.Display();
    
        Cpmv c4(move(c1));
        c4.Display();
    
        Cpmv c5;
        c5 = move(c2);
        c5.Display();
    
        return 0;
    }
    
    Cpmv::Cpmv() {
        pi = new Info;
        pi->qcode = "";
        pi->zcode = "";
        cout << "Cpmv() called.\n";
    }
    
    Cpmv::Cpmv(std::string q, std::string z) {
        pi = new Info;
        pi->qcode = q;
        pi->zcode = z;
        cout << "Cpmv(std::string q, std::string z) called.\n";
    }
    
    Cpmv::Cpmv(const Cpmv &cp) {
        pi = new Info;
        pi->qcode = cp.pi->qcode;
        pi->zcode = cp.pi->zcode;
        cout << "Cpmv(const Cpmv &cp) called.\n";
    }
    
    Cpmv::Cpmv(Cpmv &&mv) {
        pi = mv.pi;
        mv.pi = nullptr;
        cout << "Cpmv(Cpmv &&mv) called.\n";
    }
    
    Cpmv::~Cpmv() {
        delete pi;
        cout << "~Cpmv()  called.\n";
    }
    
    Cpmv &Cpmv::operator=(const Cpmv &cp) {
        cout << "Cpmv &operator=(const Cpmv &cp) called.\n";
        if (this == &cp) {
            return *this;
        }
        delete pi;
        pi = new Info;
        pi->qcode = cp.pi->qcode;
        pi->zcode = cp.pi->zcode;
        return *this;
    }
    
    Cpmv &Cpmv::operator=(Cpmv &&mv) {
        cout << "Cpmv &operator=(Cpmv &&mv) called.\n";
        if (this == &mv) {
            return *this;
        }
        delete pi;
        pi = mv.pi;
        mv.pi = nullptr;
        return *this;
    }
    
    Cpmv Cpmv::operator+(const Cpmv &obj) const {
        cout << "Cpmv operator+(const Cpmv &obj) called.\n";
        Cpmv cv;
        cv.pi->qcode = this->pi->qcode + obj.pi->qcode;
        cv.pi->zcode = this->pi->zcode + obj.pi->zcode;
        return cv;
    }
    
    void Cpmv::Display() const {
        cout << "The qcode is " << this->pi->qcode << endl;
        cout << "The zcode is " << this->pi->zcode << endl;
    }

**3. 编写并测试可变参数模板函数sum\_value( )，它接受任意长度的参数列表（其中包含数值，但可以是任何类型），并以long double的方式返回这些数值的和。**

main.cpp:

#include <iostream>
    #include <string>
    
    // definition for 1 parameter
    template <typename T>
    long double sum_value(const T& value) {
      return value;
    }
    
    // definition for 2 or more parameters
    template <typename T, typename... Args>
    long double sum_value(const T& value, const Args&... args) {
      return value + sum_value(args...);
    }
    
    int main() {
      int n = 14;
      double x = 2.71828;
      std::cout << sum_value(n, x, 'a') << std::endl;
      return 0;
    }

**4. 使用lambda重新编写程序清单16.15。具体地说，使用一个有名称的lambda替换函数outint( )，并将函数符替换为两个匿名lambda表达式。**

main.cpp:

#include <algorithm>
    #include <iostream>
    #include <iterator>
    #include <list>
    
    auto outint_l = [](int n) { std::cout << n << " "; };
    
    int main() {
        using std::cout;
        using std::endl;
        using std::list;
        int vals[10] = {50, 100, 90, 180, 60, 210, 415, 88, 188, 201};
        list<int> yadayada(vals, vals + 10);  // range constructor
        list<int> etcetera(vals, vals + 10);
        // C++11 can use the following instead
        // list<int> yadayada = {50, 100, 90, 180, 60, 210, 415, 88, 188, 201};
        // list<int> etcetera {50, 100, 90, 180, 60, 210, 415, 88, 188, 201};
        cout << "Original lists:\n";
        for_each(yadayada.begin(), yadayada.end(), outint_l);
        cout << endl;
        for_each(etcetera.begin(), etcetera.end(), outint_l);
        cout << endl;
        yadayada.remove_if(
            [](int n) { return n > 100; });  // use a named function object
        etcetera.remove_if(
            [](int n) { return n > 200; });  // construct a function object
        cout << "Trimmed lists:\n";
        for_each(yadayada.begin(), yadayada.end(), outint_l);
        cout << endl;
        for_each(etcetera.begin(), etcetera.end(), outint_l);
        cout << endl;
        return 0;
    }