实验三

任务一：

button.hpp

#pragma once
#include<iostream>
#include<string>
class Button
{
    public:
        Button(const std::string &label_);
        const std::string& get_label() const;
        void click();
    private:
        std::string label;    
};
Button::Button(const std::string &label_): label{label_}
{    
  } 
inline const std::string &Button ::get_label()const
{
    return label;
   }  
inline void Button::click()
{
    std::cout<<"Button"<<label<<"clicked\n";
    }

window.hpp

#pragma once
#include<iostream>
#include<vector>
#include<algorithm>
#include "button.hpp"
class Window
{
    public:
        Window(const std::string &title_);
        void display() const;
        void close();
        void add_button(const std::string &label);
        void click_button(const std::string &label);
        private:
            bool has_button(const std::string &label)const;
        private:
                std::string title;
                std::vector<Button> buttons;    
};
Window::Window(const std::string &title_):title{title_}
{
  buttons.push_back(Button("close"));    
}
inline void Window::display() const
{
    std::string s(40,'*');
    std::cout <<s<<std::endl;
    std::cout<<"window:"<<title<<std::endl;
    int cnt=0;
    for(const auto &button:buttons)
        std::cout<<++cnt<<"."<<button.get_label()<<std::endl;
        std::cout<<s<<std::endl;
    
}
inline void Window::close()
{
    std::cout<<"close window'"<<title<<"'"<<std::endl;
    click_button("close");
}
inline bool Window::has_button(const std::string &label) const
{
    for(const auto &button:buttons)
      if(button.get_label()==label)
       return true;
    return false; 
}
inline void Window::add_button(const std::string &label)
{
    if(has_button(label))
       std::cout<<"button "<<label<<" already exists!\n";
    else
    buttons.push_back(Button(label));    
}
inline void Window::click_button(const std::string &label)
{
    for(auto &button:buttons)
      if(button.get_label()==label)
      {
          button.click();
          return;
      }
      std::cout<<"no button:"<<label<<std::endl;
 } 

task1.cpp

#include "window.hpp"
#include <iostream>
 void test()
 {
    Window w("Demo");
    w.add_button("add");
    w.add_button("remove");
    w.add_button("modify");
    w.add_button("add");
    w.display();
    w.close();
 }
 int main()
  {
    std::cout << "用组合类模拟简单GUI:\n";
    test();
}

运行结果截图

问题1：这个范例中，Window和Button是组合关系吗？
   答：是组合关系，因为Window的对象包含Button对象作为组成部分
问题2： bool has_button(const std::string &label) const; 被设计为私有。 思考并回答：
（1）若将其改为公有接口，有何优点或风险？
    答：外部代码可以检测按钮是否存在，但会破坏封装性。
（2）设计类时，如何判断一个成员函数应为 public 还是 private？（可从“用户是否需要”、“是否仅为内部实现细节”、“是否易破坏对象状态”等角度分析。）
    答：看函数是否是用户调用的核心功能，接口，是的话用public，如果只是为内部实现细节或者会破坏对象完整性用private
问题3：Button 的接口const std::string& get_label() const;返回const std::string& 。对比以下两种接口设计在性能和安全性方面的差异并精炼陈述。
接口1：const std::string& get_label() const;
接口2：const std::string get_label() const;
    答：接口1返回的是引用，2返回的是字符串的拷贝，2更加安全因为返回的是一个拷贝副本，不对拷贝对象有影响

问题4：把代码中所有 xx.push_back(Button(xxx)) 改成 xx.emplace_back(xxx) ，观察程序是否正常运行；查阅资料，回答两种写法的差别。
     答：可以正常运行。push_back(Button(xxx))先构造一个临时对象再将临时对象复制到vector中，而emplace_back(xxx)：直接在vector的中构造对象。

任务二：

task2.cpp

#include<iostream>
#include<vector>
void test1();
void test2();
void output1(const std::vector<int> &v);
void output2(const std::vector<int> &v);
void output3(const std::vector<std::vector<int>>&v);
int main()
{
    std::cout<<"深刻复制1：标准库vector<int>\n";
    test1();
    std::cout<<"\n深刻复制2：标准库vector<int>嵌套使用\n";
    test2();
}
void test1()
{
    std::vector<int> v1(5,42);
    const std::vector<int> v2(v1);
    std::cout<<"**********拷贝构造后**********\n";
    std::cout<<"v1: ";
    output1(v1);
    std::cout<<"v2: ";
    output1(v2);
    v1.at(0)=-1;
    std::cout<<"**********修改v1[0]后**********\n"; 
    std::cout<<"v1: ";
    output1(v1);
    std::cout<<"v2: ";
    output1(v2);
}
   void test2()
   {
       std::vector<std::vector<int>>v1{{1,2,3},{4,5,6,7}};
    const std::vector<std::vector<int>>v2(v1);    
    std::cout << "**********拷贝构造后**********\n";
    std::cout << "v1: "; output3(v1);
    std::cout << "v2: "; output3(v2);
    v1.at(0).push_back(-1);
    std::cout << "**********修改v1[0]后**********\n";
    std::cout << "v1: \n";  output3(v1);
    std::cout << "v2: \n";  output3(v2);
   }
   void output1(const std::vector<int> &v)
   {
       if(v.size()==0)
       {
           std::cout<<'\n';
           return;
       }
    std::cout<<v.at(0);
    for(auto i=1;i<v.size();++i)
       std::cout<<", "<<v.at(i);
    std::cout<<'\n';
   }
   void output2(const std::vector<int> &v)
   {
       if(v.size()==0)
       {
           std::cout<<'\n';
           return; 
       }
    auto it=v.begin();
    std::cout<<*it;
    for(it=v.begin()+1;it!=v.end();++it)
      std::cout<<", "<<*it;
    std::cout<<'\n';     
   }
   void output3(const std::vector<std::vector<int>> &v)
   {
     if(v.size()==0)
     {
         std::cout<<'\n';
         return;
         }    
    for(auto &i:v)     
       output2(i);
    } 

运行结果截图

问题1：测试模块1中这两行代码分别完成了什么构造？ v1、v2 各包含多少个值为 42 的数据项
    答：v1使用了类vector的带参的构造函数，而v2是复制构造函数。v1,v2都包含5个42.
问题2：测试模块2中这两行代码执行后, v1.size()、v2.size()、v1[0].size()分别是多少？

  答：v1.size()=2，v2.size()=2，v1[0].size()=3

问题3：测试模块1中，把 v1.at(0) = -1;写成 v1[0] = -1;能否实现同等效果？两种用法有何区别？

 

  答：可以实现等同效果。区别是：at() 成员函数会进行边界检查，而operator[]不会。

问题4：测试模块2中执行 v1.at(0).push_back(-1); 后

（1） 用以下两行代码，能否输出-1？为什么？

  答：可以。因为首先v1.at(0).push_back(-1); 作用是在v1的第一个内部量（{1, 2, 3}）尾部添加元素-1。

        std::vector<int> &r = v1.at(0); r引用v1的第一个量，而r.at(r.size()-1) 访问该量的最后一个元素即为-1

（2）r定义成用const &类型接收返回值，在内存使用上有何优势？有何限制？

   答：r用引用的方式，节省内存。但限制是r不能更改所引用的量。
问题5：观察程序运行结果，反向分析、推断：
（1） 标准库模板类vector 的复制构造函数实现的是深复制还是浅复制？
   答：深复制。深复制中原量和复制量是独立的，修改其中一个不会影响另一个。实验中v1修改后有了-1，但v2并没有更改。
（2）vector<T>::at() 接口思考： 当 v是vector<int> 时，v.at(0) 返回值类型是什么？当v是const vector<int> 时，v.at(0) 返回值类型又是什么？据此推断at() 是否必须提供带 const 修饰的重载版本？
   答： 当 v是vector<int> 时，v.at(0) 返回类型为 int&，允许修改。当 v 是 const vector<int> 时，v.at(0) 返回类型为 const int&，不能修改。at() 成员函数必须提供，这样const类型也可以调用。

任务三：

vectorInt.hpp

  

#pragma once
#include<iostream>
class vectorInt
{
    public:
         vectorInt();
        vectorInt(int n_);
        vectorInt(int n_,int value);
        vectorInt(const vectorInt &vi);
        ~vectorInt();
        int size() const;
        int& at(int index) ;
        const int& at(int index) const;
        vectorInt &assign(const vectorInt &vi);
        int *begin();
        int *end();
        const int*begin() const;
        const int *end() const;
    private:
        int n;
        int *ptr;     
};
vectorInt::    vectorInt():n{0},ptr{nullptr}
{
 }
vectorInt::vectorInt(int n_):n{n_},ptr{new int[n]}
{
 }
vectorInt::vectorInt(int n_,int value):n{n_},ptr{new int[n_]}
{
    for(auto i=0;i<n;++i)
       ptr[i]=value;
  } 
vectorInt::vectorInt(const vectorInt &vi):n{vi.n},ptr{new int[n]}
{
    for(auto i=0;i<n;++i)
      ptr[i]=vi.ptr[i];
   }   
vectorInt::~vectorInt() 
{
    delete [] ptr;
  }  
int vectorInt::size() const
{
    return n;
  }   
const int &vectorInt::at(int index) const
{
    if(index<0||index>=n)
    {
        std::cerr<<"IndexError:index out of range\n";
        std::exit(1);
    }
   return ptr[index];
}
int& vectorInt::at(int index)
{
    if(index<0||index>=n)
      {
          std::cerr<<"IndexError:index out of range\n";
        std::exit(1);
      }
    return ptr[index];  
 } 
vectorInt& vectorInt::assign(const vectorInt &vi)
{
    if(this==&vi)
       return *this;
    int *ptr_tmp;
    ptr_tmp=new int[vi.n];
    for(int i=0;i<vi.n;++i)
       ptr_tmp[i]=vi.ptr[i];
    delete [] ptr;
    n=vi.n;
    ptr=ptr_tmp;
    return *this;       
 } 
int *vectorInt::begin() 
{
    return ptr;
}
int *vectorInt::end() 
{
    return ptr+n;
}
const int* vectorInt::begin() const
{ 
 return ptr;
 }
 const int* vectorInt::end() const
  {
 return ptr+n;
 }

task3.cpp

#include "vectorInt.hpp"
#include <iostream>
 void test1();
 void test2();
 void output1(const vectorInt &vi);
 void output2(const vectorInt &vi);
 int main()
{
 std::cout << "测试1: \n";
 test1();
 std::cout << "\n测试2: \n";
 test2();
 }
 void test1()
{
 int n;
 std::cout << "Enter n: ";
 std::cin >> n;
 vectorInt x1(n);
 for(auto i=0;i<n;++i)
   x1.at(i)=(i+1)*10;
   std::cout<<"x1: ";
   output1(x1);
 vectorInt x2(n,42);       
 vectorInt x3(x2);
 x2.at(0)=-1;
 std::cout<<"x2: ";
 output1(x2);
 std::cout<<"x3: ";
 output1(x3);
  }
 void test2()
 {
     const vectorInt x(5,42);
     vectorInt y;
     y.assign(x);
     std::cout<<"x: ";
     output2(x);
     std::cout<<"y: ";
    output2(y);  
 }
 void output1(const vectorInt &vi)
 {
     if(vi.size()==0)
     {
     std::cout<<'\n';
     return;
    }
    std::cout<<vi.at(0);
    for(auto i=1;i<vi.size();++i)
      std::cout<<", "<<vi.at(i);
    std::cout<<'\n';  
 }
 void output2(const vectorInt &vi)
 {
     if(vi.size()==0)
     {
         std::cout<<'\n';
         return;
     }
    auto it=vi.begin();
    std::cout<<*it;
    for(it=vi.begin()+1;it!=vi.end();++it)
      std::cout<<", "<<*it;
    std::cout<<'\n';   
 }

运行结果截图

问题1：当前验证性代码中， vectorInt 接口 assign 实现是安全版本。如果把 assign 实现改成版本2， 逐条指出版本 2存在的安全隐患和缺陷。（提示：对比两个版本，找出差异化代码，加以分析）

   答：版本二先执行delete[] ptr;，释放ptr 。随后，当访问 vi.ptr[i]时，会产生未定义错误。

       版本二 先delete后再调用了new,如果重新分配失败，会泄露数据

     版本二在最开始delete[] ptr;后面不再处理ptr

问题2：当前验证性代码中，重载接口at内部代码完全相同。若把非 const 版本改成如下实现，可消除重复并遵循“最小化接口”原则（未来如需更新接口，只更新const接口，另一个会同步）。
  查阅资料，回答：

（1）static_cast<const vectorInt*>(this) 的作用是什么？转换前后this 的类型分别是什么？转换目的？
   答:转换前this 的类型是 vectorInt*，转换后：const vectorInt*，目的：通过将 this 转换为指向const类型的指针，可调用const函数

（2）const_cast<int&> 的作用是什么？转换前后的返回类型分别是什么？转换目的？
     答：转换前返回的是 const int&。转换后是 int&，目的：因为原对象是非const的，要返回非const的引用，所以通过const_cast将const引用转换为非const引用

问题3：vectorInt类封装了begin()和end()的const/非const接口。
（1）以下代码片段，分析编译器如何选择重载版本，并总结这两种重载分别适配什么使用场景。

   答：由于v1非const对象，选择非const的begin()，由于v2是const对象选择const版本的begin()。

         非const用于需要修内容的场景，const版本：用于读取但不修改的场景。

问题4：以下两个构造函数及assign接口实现，都包含内存块的赋值/复制操作。使用算法库<algorithm>改写是否可以？回答这3行更新代码的功能
   答：可以，std::fill_n(ptr, n, value)是将ptr中 n 个元素都置为 value

std::copy_n(vi.ptr, vi.n, ptr)将vi.ptr中 n 个元素复制到ptr中

std::copy_n(vi.ptr, vi.n, ptr_tmp)将vi.ptr中 n 个元素复制到临时创建的ptr_tmp中

任务四：

matrix.hpp

#pragma once
class Matrix
{
    public:
        Matrix(int rows_,int cols_,double value =0);
        Matrix(int rows_,double value=0);
        Matrix(const Matrix &x);
        ~Matrix();
        void set(const double *pvalue,int size);
        void clear();
        const double& at(int i,int j) const;
        double& at(int i,int j);
        int rows() const;
        int cols() const;
        void print() const;
    private:
        int n_rows;
        int n_cols;
        double *ptr;    
};

matrix.cpp

#include <iostream>
#include <cstdlib>
#include "matrix.hpp"
 Matrix::Matrix(int rows_, int cols_, double value):n_rows{rows_},n_cols{cols_},ptr{new double[rows_*cols_]} 
 {
    for(auto  i=0;i<n_rows*n_cols;++i)
       ptr[i]=value;     
 }
 Matrix::Matrix(int rows_, double value ):n_rows{rows_},n_cols{rows_},ptr{new double[n_rows*n_cols]}   
 {
     for(auto  i=0;i<n_rows*n_rows;++i)
       ptr[i]=value;     
 }
 Matrix::Matrix(const Matrix &x):n_rows{x.n_rows},n_cols{x.n_cols},ptr{new double[x.n_cols*x.n_rows]} 
 {
   for(auto i=0;i<n_rows*n_cols;i++)
      
        ptr[i]=x.ptr[i];    
      }     
 Matrix::~Matrix()
 {
     delete [] ptr; 
 }
 void Matrix::set(const double *pvalue, int size)   
{
    if(size!=rows()*cols())
      exit(1);
    for(auto i=0;i<size;++i)
       ptr[i]=pvalue[i];  
}
 void Matrix::clear()
{    
    for(int i = 0; i < rows() * cols(); ++i) 
        ptr[i] = 0.0;
}
 const double& Matrix::at(int i, int j) const
 {
   if(i<0||i>=rows()||j<0||j>=cols())
   exit(1);
   else
     return ptr[i*cols()+j];
   
 }

double& Matrix::at(int i, int j) 
{
   if(i<0||i>=rows()||j<0||j>=cols())
   exit(1);
   else
     return ptr[i*cols()+j]; 
 }
  
int Matrix::rows() const
{
    return n_rows;
 } 
int Matrix::cols() const 
{
    return n_cols;
 } 
void Matrix::print() const
{
    int i,j;
      for( i=0;i<rows();i++)
        {
        for( j=0;j<cols();j++)
            {
            std::cout<<ptr[i*cols()+j]; 
            if(j < cols() - 1) 
                std::cout << ", ";
            }  
     
      std::cout<<std::endl;
}}

task4.cpp

#include <iostream>
#include <cstdlib>
#include "matrix.hpp"
 void test1();
 void test2();
 void output(const Matrix &m,int row_index);
 int main()
 {
 std::cout << "测试1: \n";
 test1(); 
 std::cout << "\n测试2: \n";
 test2();
}
 void test1() 
 {
 double x[1000] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 int n, m;
 std::cout << "Enter n and m: ";
 std::cin >> n >> m;
 Matrix m1(n,m);
 m1.set(x,n*m);
 Matrix m2(m,n);
 m2.set(x,m*n);
 Matrix m3(n);
 m3.set(x,n*n);
 std::cout << "矩阵对象m1: \n";
 m1.print();
 std::cout << "矩阵对象m2: \n";   
 m2.print();
 std::cout << "矩阵对象m3: \n";   
 m3.print();
 }
 void test2()
 {
     Matrix m1(2,3,-1);
     const Matrix m2(m1);
    std::cout << "矩阵对象m1: \n";   
    m1.print();
    std::cout << "矩阵对象m2: \n";   
    m2.print();
    m1.clear();
    m1.at(0,0)=1;
    std::cout<<"m1更新后: \n";
    std::cout<<"矩阵对象m1第0行 ";
    output(m1, 0);
    std::cout << "矩阵对象m2第0行: "; 
    output(m2, 0);
}
  void output(const Matrix &m,int row_index)
  {
      if(row_index<0||row_index>m.rows())
      {
          std::cerr<<"IndexError: row  index out of range\n";
          std::exit(1);    
      }
    std::cout<<m.at(row_index,0);
    for(int j=1;j<m.cols();++j)
      std::cout<<", "<<m.at(row_index,j);
    std::cout<<'\n';    
  }

运行结果截图

任务五：

contact.hpp

#pragma once
#include <iostream>
#include <string>
class Contact
{
    public:
        Contact(const std::string &name_,const std::string &phone_);
        const std::string &get_name() const;
        const std::string &get_phone() const;
        void display() const;
    private:
        std::string name;
        std::string phone; 
};
Contact::Contact(const std::string &name_,const std::string &phone_):name{name_},phone{phone_}
{
}
const std::string& Contact::get_name() const
{
    return name;
 } 
const std::string& Contact::get_phone() const
{
    return phone;
 } 
void Contact::display() const
{
    std::cout<<name<<", "<<phone;    
 } 

contactBook.hpp

# pragma once
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "contact.hpp"
class ContactBook
{
    public:
        void add(const std::string &name,const std::string &phone);
        void remove(const std::string &name);
        void find(const std::string &name) const;
        void display() const;
        size_t size() const;
    private:
        int index(const std::string &name) const;
        void sort();     
    private:
        std::vector<Contact> contacts;    
};
void ContactBook::add(const std::string &name,const std::string &phone)
{
    if(index(name)==-1)
    {
        contacts.push_back(Contact(name,phone));
        std::cout<<name<<" add successfully.\n";
        sort(); 
        return; 
    }
    std::cout<<name<<" already exists. fail to add!\n";
}
void ContactBook::remove(const std::string &name)
{
    int i=index(name);
    if(i==-1)
    {
        std::cout<<name<<" not found,fail to remove!\n";
        return;
    }
    contacts.erase(contacts.begin()+i);
    std::cout<<name<<" remove successfully.\n";
} 
void ContactBook::find(const std::string &name) const
{
    int i=index(name);
    if(i==-1)
    {
      std::cout<<name<<" not find!\n";
      return;        
    }    
    contacts[i].display();
    std::cout<<'\n';                
    }    
void ContactBook::display() const
{
    for(auto &c:contacts)
    {
        c.display();
        std::cout<<'\n';
    }
}
size_t ContactBook::size() const
{
    return contacts.size();
    }    
int ContactBook::index(const std::string &name) const
{
    int i;
   for(i=0;i<contacts.size();i++)
      if(contacts[i].get_name()==name)      
            return i;
    if(i==size())
        return -1;
}
void ContactBook::sort()
{
    int i,j;
    
    for(i=0;i<contacts.size()-1;i++)
        for(j=0;j<contacts.size()-1-i;j++)     
        {
             if(contacts[j].get_name()>contacts[j+1].get_name())       
                std:: swap(contacts[j],contacts[j+1]);
     }             
}

task5.cpp

#include "contactBook.hpp"
void test()
{
    ContactBook contactbook;
    std::cout<<"1. add contacts\n";
    contactbook.add("Bob", "18199357253");
    contactbook.add("Alice", "17300886371");
    contactbook.add("Linda", "18184538072");
    contactbook.add("Alice", "17300886371");
    std::cout << "\n2. display contacts\n";
    std::cout << "There are " << contactbook.size() << " contacts.\n";
    contactbook.display();
    std::cout << "\n3. find contacts\n";
    contactbook.find("Bob");
    contactbook.find("David");
    std::cout << "\n4. remove contact\n";
    contactbook.remove("Bob");
    contactbook.remove("David");
 }
 int main()
{
    test();
 }

运行结果截图