实验5
实验任务1：
publisher.hpp源代码：
1 #pragma once 2 3 #include <string> 4 5 // 发行/出版物类：Publisher （抽象类） 6 class Publisher { 7 public: 8 Publisher(const std::string &name_ = ""); // 构造函数 9 virtual ~Publisher() = default; 10 11 public: 12 virtual void publish() const = 0; // 纯虚函数，作为接口继承 13 virtual void use() const = 0; // 纯虚函数，作为接口继承 14 15 protected: 16 std::string name; // 发行/出版物名称 17 }; 18 19 // 图书类: Book 20 class Book: public Publisher { 21 public: 22 Book(const std::string &name_ = "", const std::string &author_ = ""); // 构造函数 23 24 public: 25 void publish() const override; // 接口 26 void use() const override; // 接口 27 28 private: 29 std::string author; // 作者 30 }; 31 32 // 电影类: Film 33 class Film: public Publisher { 34 public: 35 Film(const std::string &name_ = "", const std::string &director_ = ""); // 构造函数 36 37 public: 38 void publish() const override; // 接口 39 void use() const override; // 接口 40 41 private: 42 std::string director; // 导演 43 }; 44 45 46 // 音乐类：Music 47 class Music: public Publisher { 48 public: 49 Music(const std::string &name_ = "", const std::string &artist_ = ""); 50 51 public: 52 void publish() const override; // 接口 53 void use() const override; // 接口 54 55 private: 56 std::string artist; // 音乐艺术家名称 57 };
publisher.cpp源代码：
1 #include <iostream> 2 #include <string> 3 #include "publisher.hpp" 4 5 // Publisher类：实现 6 Publisher::Publisher(const std::string &name_): name {name_} { 7 } 8 9 10 // Book类: 实现 11 Book::Book(const std::string &name_ , const std::string &author_ ): Publisher{name_}, author{author_} { 12 } 13 14 void Book::publish() const { 15 std::cout << "Publishing book《" << name << "》 by " << author << '\n'; 16 } 17 18 void Book::use() const { 19 std::cout << "Reading book 《" << name << "》 by " << author << '\n'; 20 } 21 22 23 // Film类：实现 24 Film::Film(const std::string &name_, const std::string &director_):Publisher{name_},director{director_} { 25 } 26 27 void Film::publish() const { 28 std::cout << "Publishing film <" << name << "> directed by " << director << '\n'; 29 } 30 31 void Film::use() const { 32 std::cout << "Watching film <" << name << "> directed by " << director << '\n'; 33 } 34 35 36 // Music类：实现 37 Music::Music(const std::string &name_, const std::string &artist_): Publisher{name_}, artist{artist_} { 38 } 39 40 void Music::publish() const { 41 std::cout << "Publishing music <" << name << "> by " << artist << '\n'; 42 } 43 44 void Music::use() const { 45 std::cout << "Listening to music <" << name << "> by " << artist << '\n'; 46 }
task1.cpp源代码：
1 #include <memory> 2 #include <iostream> 3 #include <vector> 4 #include "publisher.hpp" 5 6 void test1() { 7 std::vector<Publisher *> v; 8 9 v.push_back(new Book("Harry Potter", "J.K. Rowling")); 10 v.push_back(new Film("The Godfather", "Francis Ford Coppola")); 11 v.push_back(new Music("Blowing in the wind", "Bob Dylan")); 12 13 for(Publisher *ptr: v) { 14 ptr->publish(); 15 ptr->use(); 16 std::cout << '\n'; 17 delete ptr; 18 } 19 } 20 21 void test2() { 22 std::vector<std::unique_ptr<Publisher>> v; 23 24 v.push_back(std::make_unique<Book>("Harry Potter", "J.K. Rowling")); 25 v.push_back(std::make_unique<Film>("The Godfather", "Francis Ford Coppola")); 26 v.push_back(std::make_unique<Music>("Blowing in the wind", "Bob Dylan")); 27 28 for(const auto &ptr: v) { 29 ptr->publish(); 30 ptr->use(); 31 std::cout << '\n'; 32 } 33 } 34 35 void test3() { 36 Book book("A Philosophy of Software Design", "John Ousterhout"); 37 book.publish(); 38 book.use(); 39 } 40 41 int main() { 42 std::cout << "运行时多态：纯虚函数、抽象类\n"; 43 44 std::cout << "\n测试1: 使用原始指针\n"; 45 test1(); 46 47 std::cout << "\n测试2: 使用智能指针\n"; 48 test2(); 49 50 std::cout << "\n测试3: 直接使用类\n"; 51 test3(); 52 }
运行测试结果：
问题1：抽象类机制
（1）是什么决定了 Publisher 是抽象类？用一句话说明，并指出代码中的具体依据。
答：抽象类是包含纯虚函数的类，代码中依据如下：
virtual void publish() const = 0;
virtual void use() const = 0;
（2）如果在 main.cpp 里直接写 Publisher p; 能否编译通过？为什么？
答：不能，因为Publisher是抽象类，抽象类不能实例化。
问题2：纯虚函数与接口继承
（1） Book 、 Film 、 Music 必须实现哪两个函数才能通过编译？请写出其完整函数声明。
答：必须实现publish和use这两个函数才能通过编译。代码中声明如下：
void publish() const override;
void use() const override;
（2） 在 publisher.cpp 的 Film 类实现中，把两个成员函数实现里的 const 去掉（保持函数体不变），重新编译，报错信息是什么？
答：报错信息如下：
严重性 代码 说明 项目 文件 行 禁止显示状态 详细信息
错误(活动) E0147 声明与 "void Film::publish() const" (已声明 所在行数:38，所属文件:"C:\Users\bw\Downloads\实验5文档代码_gbk\实验5文档代码_gbk\1\publisher.hpp") 不兼容 实验 C:\Users\bw\Downloads\实验5文档代码_gbk\实验5文档代码_gbk\1\publisher.cpp 27
严重性 代码 说明 项目 文件 行 禁止显示状态 详细信息
错误(活动) E0147 声明与 "void Film::use() const" (已声明 所在行数:31) 不兼容 实验 C:\Users\bw\Downloads\实验5文档代码_gbk\实验5文档代码_gbk\1\publisher.cpp 31
因为派生类实现的函数签名需要与纯虚函数一致，纯虚函数有const限定，派生类的函数也需要有const限定。
问题3：运行时多态与虚析构
（1）在 test1() 里， for (Publisher *ptr : v) 中 ptr 的声明类型是什么？
答：Publisher*
（2）当循环执行到 ptr->publish(); 时， ptr 实际指向的对象类型分别有哪些？（按循环顺序写出）
答：Book、Film、Music
（3）基类 Publisher 的析构函数为何声明为 virtual ？若删除 virtual ，执行 delete ptr; 会出现什么问题？
答：析构函数声明为virtual是为了派生类都能够使用析构函数进行资源释放，如果删除virtual会导致delete ptr只能释放基类的资源。
实验任务2：
book.hpp源代码：
1 #pragma once 2 #include <string> 3 4 // 图书描述信息类Book: 声明 5 class Book { 6 public: 7 Book(const std::string &name_, 8 const std::string &author_, 9 const std::string &translator_, 10 const std::string &isbn_, 11 double price_); 12 13 friend std::ostream& operator<<(std::ostream &out, const Book &book); 14 15 private: 16 std::string name; // 书名 17 std::string author; // 作者 18 std::string translator; // 译者 19 std::string isbn; // isbn号 20 double price; // 定价 21 };
book.cpp源代码：
1 #include <iomanip> 2 #include <iostream> 3 #include <string> 4 #include "book.hpp" 5 6 7 // 图书描述信息类Book: 实现 8 Book::Book(const std::string &name_, 9 const std::string &author_, 10 const std::string &translator_, 11 const std::string &isbn_, 12 double price_):name{name_}, author{author_}, translator{translator_}, isbn{isbn_}, price{price_} { 13 } 14 15 // 运算符<<重载实现 16 std::ostream& operator<<(std::ostream &out, const Book &book) { 17 using std::left; 18 using std::setw; 19 20 out << left; 21 out << setw(15) << "书名:" << book.name << '\n' 22 << setw(15) << "作者:" << book.author << '\n' 23 << setw(15) << "译者:" << book.translator << '\n' 24 << setw(15) << "ISBN:" << book.isbn << '\n' 25 << setw(15) << "定价:" << book.price; 26 27 return out; 28 }
booksale.hpp源代码：
1 #pragma once 2 3 #include <string> 4 #include "book.hpp" 5 6 // 图书销售记录类BookSales：声明 7 class BookSale { 8 public: 9 BookSale(const Book &rb_, double sales_price_, int sales_amount_); 10 int get_amount() const; // 返回销售数量 11 double get_revenue() const; // 返回营收 12 13 friend std::ostream& operator<<(std::ostream &out, const BookSale &item); 14 15 private: 16 Book rb; 17 double sales_price; // 售价 18 int sales_amount; // 销售数量 19 };
booksale.cpp源代码：
1 #include <iomanip> 2 #include <iostream> 3 #include <string> 4 #include "booksale.hpp" 5 6 // 图书销售记录类BookSales：实现 7 BookSale::BookSale(const Book &rb_, 8 double sales_price_, 9 int sales_amount_): rb{rb_}, sales_price{sales_price_}, sales_amount{sales_amount_} { 10 } 11 12 int BookSale::get_amount() const { 13 return sales_amount; 14 } 15 16 double BookSale::get_revenue() const { 17 return sales_amount * sales_price; 18 } 19 20 // 运算符<<重载实现 21 std::ostream& operator<<(std::ostream &out, const BookSale &item) { 22 using std::left; 23 using std::setw; 24 25 out << left; 26 out << item.rb << '\n' 27 << setw(15) << "售价:" << item.sales_price << '\n' 28 << setw(15) << "销售数量:" << item.sales_amount << '\n' 29 << setw(15) << "营收:" << item.get_revenue(); 30 31 return out; 32 }
task2.cpp源代码：
1 #include <algorithm> 2 #include <iomanip> 3 #include <iostream> 4 #include <string> 5 #include <vector> 6 #include "booksale.hpp" 7 8 // 按图书销售数量比较 9 bool compare_by_amount(const BookSale &x1, const BookSale &x2) { 10 return x1.get_amount() > x2.get_amount(); 11 } 12 13 void test() { 14 using std::cin; 15 using std::cout; 16 using std::getline; 17 using std::sort; 18 using std::string; 19 using std::vector; 20 using std::ws; 21 22 vector<BookSale> sales_records; // 图书销售记录表 23 24 int books_number; 25 cout << "录入图书数量: "; 26 cin >> books_number; 27 28 cout << "录入图书销售记录\n"; 29 for(int i = 0; i < books_number; ++i) { 30 string name, author, translator, isbn; 31 double price; 32 cout << string(20, '-') << "第" << i+1 << "本图书信息录入" << string(20, '-') << '\n'; 33 cout << "录入书名: "; getline(cin>>ws, name); 34 cout << "录入作者: "; getline(cin>>ws, author); 35 cout << "录入译者: "; getline(cin>>ws, translator); 36 cout << "录入isbn: "; getline(cin>>ws, isbn); 37 cout << "录入定价: "; cin >> price; 38 39 Book book(name, author, translator, isbn, price); 40 41 double sales_price; 42 int sales_amount; 43 44 cout << "录入售价: "; cin >> sales_price; 45 cout << "录入销售数量: "; cin >> sales_amount; 46 47 BookSale record(book, sales_price, sales_amount); 48 sales_records.push_back(record); 49 } 50 51 // 按销售册数排序 52 sort(sales_records.begin(), sales_records.end(), compare_by_amount); 53 54 // 按销售册数降序输出图书销售信息 55 cout << string(20, '=') << "图书销售统计" << string(20, '=') << '\n'; 56 for(auto &record: sales_records) { 57 cout << record << '\n'; 58 cout << string(40, '-') << '\n'; 59 } 60 } 61 62 int main() { 63 test(); 64 }
运行测试截图：
问题1：重载运算符<<
（1）找出运算符 << 被重载了几处？分别用于什么类型？
答：被重载了2次，分别用于book和booksale类型。
（2）找出使用重载 << 输出对象的代码，写在下面。
答：代码如下：
out << item.rb << '\n'
for(auto &record: sales_records) {
cout << record << '\n';
cout << string(40, '-') << '\n';
}
本来需要一个个读取里面的部分数据进行输出，但是通过重载运算符，就可以用cout << record << '\n';这样一行的代码先通过这个代码out << item.rb << '\n'嵌套重载<<输出，最后输出这一整个对象的完整信息。
实验任务4：
pet.hpp源代码：
1 #pragma once 2 3 #include<string> 4 5 class MachinePet{ 6 protected: 7 std::string nickname; 8 public: 9 MachinePet(const std::string& nn):nickname{nn}{} 10 virtual ~MachinePet() = default; 11 std::string get_nickname() const { return nickname; }; 12 virtual std::string talk() const =0; 13 }; 14 15 class PetCat : public MachinePet{ 16 public: 17 PetCat(const std::string& nn) :MachinePet{ nn } {}; 18 std::string talk() const override { return "miao wu~"; } 19 }; 20 21 class PetDog : public MachinePet { 22 public: 23 PetDog(const std::string& nn) :MachinePet{ nn } {}; 24 std::string talk() const override { return "wang wang~"; } 25 };
task4.cpp源代码：
1 #include <iostream> 2 #include <memory> 3 #include <vector> 4 #include "pet.hpp" 5 6 void test1() { 7 std::vector<MachinePet*> pets; 8 9 pets.push_back(new PetCat("miku")); 10 pets.push_back(new PetDog("da huang")); 11 12 for (MachinePet* ptr : pets) { 13 std::cout << ptr->get_nickname() << " says " << ptr->talk() << '\n'; 14 delete ptr; // 须手动释放资源 15 } 16 } 17 18 void test2() { 19 std::vector<std::unique_ptr<MachinePet>> pets; 20 21 pets.push_back(std::make_unique<PetCat>("miku")); 22 pets.push_back(std::make_unique<PetDog>("da huang")); 23 24 for (auto const& ptr : pets) 25 std::cout << ptr->get_nickname() << " says " << ptr->talk() << '\n'; 26 } 27 28 void test3() { 29 // MachinePet pet("little cutie"); // 编译报错：无法定义抽象类对象 30 31 const PetCat cat("miku"); 32 std::cout << cat.get_nickname() << " says " << cat.talk() << '\n'; 33 34 const PetDog dog("da huang"); 35 std::cout << dog.get_nickname() << " says " << dog.talk() << '\n'; 36 } 37 38 int main() { 39 std::cout << "测试1: 使用原始指针\n"; 40 test1(); 41 42 std::cout << "\n测试2: 使用智能指针\n"; 43 test2(); 44 45 std::cout << "\n测试3: 直接使用类\n"; 46 test3(); 47 }
运行测试截图：
实验任务5：
Complex.hpp源代码：
1 #include<iostream> 2 template<typename T> 3 class Complex { 4 private: 5 T imag; 6 T real; 7 public: 8 Complex() : imag{0},real{0}{} 9 Complex(T r, T i):imag{i},real{r}{} 10 Complex(const Complex& c):imag{c.imag}, real{c.real}{} 11 12 T get_imag() const { return imag; } 13 T get_real() const { return real; } 14 15 16 //输出 17 friend std::ostream& operator<<(std::ostream& os, const Complex& c) 18 { 19 os << c.real; 20 if (c.imag >= 0) 21 { 22 os << " + "; 23 os << c.imag << "i"; 24 } 25 else 26 { 27 os << " - "; 28 os << -c.imag << "i"; 29 } 30 return os; 31 } 32 33 //输入 34 friend std::istream& operator>>(std::istream& is, Complex& c) 35 { 36 is >> c.real; 37 is >> c.imag; 38 return is; 39 } 40 41 friend Complex operator+(Complex c1, const Complex& c2) 42 { 43 Complex c3{ c1.imag + c2.imag,c1.real + c2.real }; 44 return c3; 45 } 46 47 Complex& operator+=(const Complex& c2) 48 { 49 imag += c2.imag; 50 real += c2.real; 51 return *this; 52 } 53 54 bool operator==(const Complex& c2) 55 { 56 if (real == c2.real && imag == c2.imag) 57 { 58 return true; 59 } 60 return false; 61 } 62 };
task5.cpp源代码：
1 #include <iostream> 2 #include "Complex.hpp" 3 4 void test1() { 5 using std::cout; 6 using std::boolalpha; 7 8 Complex<int> c1(2, -5), c2(c1); 9 10 cout << "c1 = " << c1 << '\n'; 11 cout << "c2 = " << c2 << '\n'; 12 cout << "c1 + c2 = " << c1 + c2 << '\n'; 13 14 c1 += c2; 15 cout << "c1 = " << c1 << '\n'; 16 cout << boolalpha << (c1 == c2) << '\n'; 17 } 18 19 void test2() { 20 using std::cin; 21 using std::cout; 22 23 Complex<double> c1, c2; 24 cout << "Enter c1 and c2: "; 25 cin >> c1 >> c2; 26 cout << "c1 = " << c1 << '\n'; 27 cout << "c2 = " << c2 << '\n'; 28 29 const Complex<double> c3(c1); 30 cout << "c3.real = " << c3.get_real() << '\n'; 31 cout << "c3.imag = " << c3.get_imag() << '\n'; 32 } 33 34 int main() { 35 std::cout << "自定义类模板Complex测试1: \n"; 36 test1(); 37 38 std::cout << "\n自定义类模板Complex测试2: \n"; 39 test2(); 40 }
运行测试截图：
总结与体会：
本次实验最让我印象深刻的是3个点，第一个是析构函数设置为虚函数，以前只是知道要这么做，但是没有想过如果不设置会引起内存泄漏。第二个是接口设计为const，因为之前没有写的意思，这次实验中不写const会因为对象是const类型导致报错，第三个就是重载运算符的函数定义，老实说这个东西我一开始只是知道是干什么的，但是我觉得写的很费解，做完实验后总结一下，函数声明部分，第一个就是返回值，然后operator加重载的运算符和大部分函数都一样，当重载的运算符作为成员函数、并且是二元运算符的时候只需要传入右操作数，意思就是左操作数就是对象本身的时候只需要传一个即可，<<和>>必须传两个，>>的对象不能是const，这种场景下，const的目的是为了安全。然后&的作用是两个，一个是为了更改对象信息，一个是为了加快运算速度，不需要拷贝。
浙公网安备 33010602011771号