实验4_CPP
任务1
源代码
GradeClac.hpp
#pragma once
#include <vector>
#include <array>
#include <string>
class GradeCalc {
public:
GradeCalc(const std::string &cname);
void input(int n); // 录入n个成绩
void output() const; // 输出成绩
void sort(bool ascending = false); // 排序 (默认降序)
int min() const; // 返回最低分（如成绩未录入，返回-1)
int max() const; // 返回最高分 （如成绩未录入，返回-1)
double average() const; // 返回平均分 （如成绩未录入，返回0.0)
void info(); // 输出课程成绩信息
private:
void compute(); // 成绩统计
private:
std::string course_name; // 课程名
std::vector<int> grades; // 课程成绩
std::array<int, 5> counts; // 保存各分数段人数（[0, 60), [60, 70), [70, 80), [80, 90), [90, 100]
std::array<double, 5> rates; // 保存各分数段人数占比
bool is_dirty; // 脏标记，记录是否成绩信息有变更
};
GradeClac.cpp
#include <algorithm>
#include <array>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#include "GradeCalc.hpp"
GradeCalc::GradeCalc(const std::string &cname):course_name{cname},is_dirty{true} {
counts.fill(0);
rates.fill(0);
}
void GradeCalc::input(int n) {
if(n < 0) {
std::cerr << "无效输入! 人数不能为负数\n";
std::exit(1);
}
grades.reserve(n);
int grade;
for(int i = 0; i < n;) {
std::cin >> grade;
if(grade < 0 || grade > 100) {
std::cerr << "无效输入! 分数须在[0,100]\n";
continue;
}
grades.push_back(grade);
++i;
}
is_dirty = true; // 设置脏标记：成绩信息有变更
}
void GradeCalc::output() const {
for(auto grade: grades)
std::cout << grade << ' ';
std::cout << std::endl;
}
void GradeCalc::sort(bool ascending) {
if(ascending)
std::sort(grades.begin(), grades.end());
else
std::sort(grades.begin(), grades.end(), std::greater<int>());
}
int GradeCalc::min() const {
if(grades.empty())
return -1;
auto it = std::min_element(grades.begin(), grades.end());
return *it;
}
int GradeCalc::max() const {
if(grades.empty())
return -1;
auto it = std::max_element(grades.begin(), grades.end());
return *it;
}
double GradeCalc::average() const {
if(grades.empty())
return 0.0;
double avg = std::accumulate(grades.begin(), grades.end(), 0.0)/grades.size();
return avg;
}
void GradeCalc::info() {
if(is_dirty)
compute();
std::cout << "课程名称:\t" << course_name << std::endl;
std::cout << "平均分:\t" << std::fixed << std::setprecision(2) << average() << std::endl;
std::cout << "最高分:\t" << max() << std::endl;
std::cout << "最低分:\t" << min() << std::endl;
if (grades.empty())
std::cout << "中位数:\t" << 0.0 << '\n';
std::vector<int> temp = grades;
std::sort(temp.begin(), temp.end());
if (grades.size() % 2 == 1)
{
std::cout << "中位数:\t" << static_cast<double>(temp[grades.size() / 2]) << '\n';
}
else
{
std::cout << "中位数:\t" << static_cast<double>((temp[grades.size() / 2 - 1] + temp[grades.size() / 2]) / 2.0) << '\n';
}
const std::array<std::string, 5> grade_range{"[0, 60) ",
"[60, 70)",
"[70, 80)",
"[80, 90)",
"[90, 100]"};
for(int i = static_cast<int>(grade_range.size())-1; i >= 0; --i)
std::cout << grade_range[i] << "\t: " << counts[i] << "人\t"
<< std::fixed << std::setprecision(2) << rates[i]*100 << "%\n";
}
void GradeCalc::compute() {
if(grades.empty())
return;
counts.fill(0);
rates.fill(0.0);
// 统计各分数段人数
for(auto grade:grades) {
if(grade < 60)
++counts[0]; // [0, 60)
else if (grade < 70)
++counts[1]; // [60, 70)
else if (grade < 80)
++counts[2]; // [70, 80)
else if (grade < 90)
++counts[3]; // [80, 90)
else
++counts[4]; // [90, 100]
}
// 统计各分数段比例
for(size_t i = 0; i < rates.size(); ++i)
rates[i] = counts[i] * 1.0 / grades.size();
is_dirty = false; // 更新脏标记
}
task1.cpp
#include <iostream>
#include <string>
#include "GradeCalc.hpp"
void test() {
GradeCalc c1("OOP");
std::cout << "录入成绩:\n";
c1.input(5);
std::cout << "输出成绩:\n";
c1.output();
std::cout << "排序后成绩:\n";
c1.sort(); c1.output();
std::cout << "*************成绩统计信息*************\n";
c1.info();
}
int main() {
test();
}
运行测试结果
问题回答
问题1
组合关系：
std::string course_name;
std::vector
std::array<int, 5> counts;
std::array<double, 5> rates;
course_name保存课程名，grades保存课程成绩，counts用数组保存各分数段人数，rates用数组保存各分数段人数占比。
问题2
c.input(5)是合法的，c.push_back(97)不合法，GradeClac中没有封装push_back()方法，也没有继承自任何类，不可用对象调用push_back()。
问题3
(1)compute()只会被调用一次，is_dirty标记用于显示成绩是否被更改，只有检测到成绩被更改才会调用compute()。
(2)不需要更改compute()调用位置，update_grade(index, new_grade)在被调用时只需要更改脏标记，在info()被调用时，compute()会自动被调用。
问题4
可以在info()函数里加。
if grades为0
cout<<"中位数="<<0.0
vector
sort(temp.begin(),temp.end())
if grades.size()不能被2整除
cout<<"中位数="<<temp[grades.size()/2]
else
cout<<"中位数="<<avg(temp[grades.size()/2-1],temp[grades.size()/2])
问题5
compute中不能去掉这两行。如果去掉，当第二次和之后调用compute()时，前几次向counts和rates填入的人数数据会影响运算结果。
问题6
(1)对程序功能没有影响
(2)对性能有影响。vector对象的reserve()方法用于预先分配足够的内存空间，在后面向grades中输入成绩时，不需要因为容器可用空间被占满而多次重新分配内存、拷贝数据。
任务2
源代码
GradeClac.hpp
#pragma once
#include <array>
#include <string>
#include <vector>
class GradeCalc: private std::vector<int> {
public:
GradeCalc(const std::string &cname);
void input(int n); // 录入n个成绩
void output() const; // 输出成绩
void sort(bool ascending = false); // 排序 (默认降序)
int min() const; // 返回最低分
int max() const; // 返回最高分
double average() const; // 返回平均分
void info(); // 输出成绩统计信息
private:
void compute(); // 计算成绩统计信息
private:
std::string course_name; // 课程名
std::array<int, 5> counts; // 保存各分数段人数（[0, 60), [60, 70), [70, 80), [80, 90), [90, 100]
std::array<double, 5> rates; // 保存各分数段占比
bool is_dirty; // 脏标记，记录是否成绩信息有变更
};
GradeClac.cpp
#include <algorithm>
#include <array>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#include "GradeCalc.hpp"
GradeCalc::GradeCalc(const std::string &cname): course_name{cname}, is_dirty{true}{
counts.fill(0);
rates.fill(0);
}
void GradeCalc::input(int n) {
if(n < 0) {
std::cerr << "无效输入! 人数不能为负数\n";
return;
}
this->reserve(n);
int grade;
for(int i = 0; i < n;) {
std::cin >> grade;
if(grade < 0 || grade > 100) {
std::cerr << "无效输入! 分数须在[0,100]\n";
continue;
}
this->push_back(grade);
++i;
}
is_dirty = true;
}
void GradeCalc::output() const {
for(auto grade: *this)
std::cout << grade << ' ';
std::cout << std::endl;
}
void GradeCalc::sort(bool ascending) {
if(ascending)
std::sort(this->begin(), this->end());
else
std::sort(this->begin(), this->end(), std::greater<int>());
}
int GradeCalc::min() const {
if(this->empty())
return -1;
return *std::min_element(this->begin(), this->end());
}
int GradeCalc::max() const {
if(this->empty())
return -1;
return *std::max_element(this->begin(), this->end());
}
double GradeCalc::average() const {
if(this->empty())
return 0.0;
double avg = std::accumulate(this->begin(), this->end(), 0.0) / this->size();
return avg;
}
void GradeCalc::info() {
if(is_dirty)
compute();
std::cout << "课程名称:\t" << course_name << std::endl;
std::cout << "平均分:\t" << std::fixed << std::setprecision(2) << average() << std::endl;
std::cout << "最高分:\t" << max() << std::endl;
std::cout << "最低分:\t" << min() << std::endl;
const std::array<std::string, 5> grade_range{"[0, 60) ",
"[60, 70)",
"[70, 80)",
"[80, 90)",
"[90, 100]"};
for(int i = static_cast<int>(grade_range.size())-1; i >= 0; --i)
std::cout << grade_range[i] << "\t: " << counts[i] << "人\t"
<< std::fixed << std::setprecision(2) << rates[i]*100 << "%\n";
}
void GradeCalc::compute() {
if(this->empty())
return;
counts.fill(0);
rates.fill(0);
// 统计各分数段人数
for(int grade: *this) {
if(grade < 60)
++counts[0]; // [0, 60)
else if (grade < 70)
++counts[1]; // [60, 70)
else if (grade < 80)
++counts[2]; // [70, 80)
else if (grade < 90)
++counts[3]; // [80, 90)
else
++counts[4]; // [90, 100]
}
// 统计各分数段比例
for(size_t i = 0; i < rates.size(); ++i)
rates[i] = counts[i] * 1.0 / this->size();
is_dirty = false;
}
task2.cpp
#include <iostream>
#include <string>
#include "GradeCalc.hpp"
void test() {
GradeCalc c1("OOP");
std::cout << "录入成绩:\n";
c1.input(5);
std::cout << "输出成绩:\n";
c1.output();
std::cout << "排序后成绩:\n";
c1.sort(); c1.output();
std::cout << "*************成绩统计信息*************\n";
c1.info();
}
int main() {
test();
}
运行测试结果
问题回答
问题1
继承关系：
class GradeClac : private vector
问题2
vector
编译不能通过，push_back()方法由vector以private方式继承给GradeClac，不能从外部直接访问。
问题3
for(auto grade : grades)直接通过vector成员自带的接口，调用容器配套的vector
for(int grade : *this)使用时，begin()、end()需要类自行提供，通过类的begin()、end()转发底层的vector容器的迭代器来遍历容器。
问题4
组合方案更适合，grades是GradeCalc的组成部分，是拥有关系。如果采用继承，GradeCalc固定有vector
任务3
源代码
Graph.hpp
#pragma once
#include <string>
#include <vector>
enum class GraphType {circle, triangle, rectangle};
// Graph类定义
class Graph {
public:
virtual void draw() {}
virtual ~Graph() = default;
};
// Circle类声明
class Circle : public Graph {
public:
void draw();
};
// Triangle类声明
class Triangle : public Graph {
public:
void draw();
};
// Rectangle类声明
class Rectangle : public Graph {
public:
void draw();
};
// Canvas类声明
class Canvas {
public:
void add(const std::string& type); // 根据字符串添加图形
void paint() const; // 使用统一接口绘制所有图形
~Canvas(); // 手动释放资源
private:
std::vector<Graph*> graphs;
};
// 4. 工具函数
GraphType str_to_GraphType(const std::string& s); // 字符串转枚举类型
Graph* make_graph(const std::string& type); // 创建图形，返回堆对象指针
Graph.cpp
#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include "Graph.hpp"
// Circle类实现
void Circle::draw() { std::cout << "draw a circle...\n"; }
// Triangle类实现
void Triangle::draw() { std::cout << "draw a triangle...\n"; }
// Rectangle类实现
void Rectangle::draw() { std::cout << "draw a rectangle...\n"; }
// Canvas类实现
void Canvas::add(const std::string& type) {
Graph* g = make_graph(type);
if (g)
graphs.push_back(g);
}
void Canvas::paint() const {
for (Graph* g : graphs)
g->draw();
}
Canvas::~Canvas() {
for (Graph* g : graphs)
delete g;
}
// 工具函数实现
// 字符串 → 枚举转换
GraphType str_to_GraphType(const std::string& s) {
std::string t = s;
std::transform(s.begin(), s.end(), t.begin(),
[](unsigned char c) { return std::tolower(c);});
if (t == "circle")
return GraphType::circle;
if (t == "triangle")
return GraphType::triangle;
if (t == "rectangle")
return GraphType::rectangle;
return GraphType::circle; // 缺省返回
}
// 创建图形，返回堆对象指针
Graph* make_graph(const std::string& type) {
switch (str_to_GraphType(type)) {
case GraphType::circle: return new Circle;
case GraphType::triangle: return new Triangle;
case GraphType::rectangle: return new Rectangle;
default: return nullptr;
}
}
demo3.cpp
#include <string>
#include "Graph.hpp"
void test() {
Canvas canvas;
canvas.add("circle");
canvas.add("triangle");
canvas.add("rectangle");
canvas.paint();
}
int main() {
test();
}
运行测试结果
问题回答
问题1
(1)组合：
std::vector<Graph*> graphs;
用基类指针数组保存指向各个图像的指针，存储图像。
(2)继承：
class Circle : public Graph
class Triangle : public Graph
class Rectangle : public Graph
问题2
(1)运行结果是什么都不输出，因为不是虚函数，在各种形状中从Graph继承的draw()没有被重写，用基类Graph指针调用时，被调用的是Graph中不做任何操作的draw()。
(2)Canvas类中的std::vector<Graph*>保存的是基类Graph的指针，可以指向派生类对象，所以可以保存从Graph派生出的各种图形。
而std::vector
(3)如果~Graph()没有声明为虚函数，则不会在运行期根据对象实际类型调用对应的析构函数。派生类如果包含动态分配的资源，但调用的是基类的析构函数，则会导致内存泄漏。
问题3
Graph.hpp中，添加：
enum class GraphType {circle, triangle, rectangle, star};
//=_=
class Star : public Graph
{
public:
void draw();
}
Graph.cpp中，添加：
void Star::draw()
{
std::cout << "draw a star...\n；"
}
GraphType str_to_GraphType(const std::string& s)
{
//....
if (t == "star")
return GraphType::star;
//....
}
Graph* make_graph(const std::string& type)
{
//...
case GraphType::star: return new Star;
//...
}
demo3.cpp中，可以添加：
void test()
{
//...
canvas.add("star");
//...
}
问题4
(1)make_graph()新增的对象在Canvas析构时被释放。
(2)优点：可以将继承自基类的不同派生类存放在一起，并且可以用基类指针进行批量管理，操作便捷。
缺点：用new分配的内存空间，如果没有delete，会导致内存泄漏；重复delete或者调用前被误释放，会产生野指针。必须通过Graph指针访问，不能直接访问派生类的特有成员。析构函数若为非虚函数，析构时会导致内存泄漏。
任务4
场景描述
factory中所有的toy支持增删，显示所有toy的信息，所有toy可以同时响应给出的指令。
类之间关系
基类Toy包含几个纯虚函数用来给派生类写不同的方法，存储的数据状态为保护，可供派生类访问，用枚举类来存储玩具类型。
DogToy,CatToy,BearToy继承自Toy类，对纯虚函数进行重写，并用override校验参数、返回值。
ToyFactory类中用一个存储Toy指针的动态数组成员来存储不同类型的Toy，并在其中封装调用让所有Toy作出动作的方法。
目前尚未解决的是如何在不将动态数组暴露给用户的情况下，对单个toy发出指令。=_=
源代码
Toy.hpp
#pragma once
#include <string>
enum class ToyType
{
UNKNOWNTOY,
DOG,
CAT,
BEAR,
};
class Toy
{
public:
Toy(const std::string& name0 = "Default Name", const std::string& material0 = "Default Material", const std::string& musicAudio0 = "DefaultSong");
virtual ~Toy();
virtual void start() = 0;
virtual void act() = 0;
virtual void playAudio() = 0;
virtual void shutdown() = 0;
void displayInfo();
const std::string& getName() const { return name; }
protected:
std::string name;
std::string material;
std::string musicAudio;
ToyType type;
};
Toy.cpp
#include "Toy.hpp"
#include <iostream>
Toy::Toy(const std::string& name0, const std::string& material0, const std::string& musicAudio0) :
name{ name0 }, material{ material0 }, musicAudio{ musicAudio0 }, type{ToyType::UNKNOWNTOY} { }
Toy::~Toy() = default;
void Toy::displayInfo()
{
std::cout << name << '\t' << material << '\t';
switch (type)
{
case ToyType::DOG:
std::cout << "Dog\t";
break;
case ToyType::CAT:
std::cout << "Cat\t";
break;
case ToyType::BEAR:
std::cout << "Bear\t";
break;
default:
std::cout << "Unknown Type\t";
}
std::cout << musicAudio << "\n";
}
DogToy.hpp
#pragma once
#include "Toy.hpp"
class DogToy : public Toy
{
public:
DogToy(const std::string& name0 = "FriendDog", const std::string& material0 = "Cotton", const std::string& musicAudio = "DefaultDogSong");
void start() override;//override表示这个函数是重写基类的虚函数，需要检查参数、返回值等是否匹配
void act() override;
void playAudio() override;
void shutdown() override;
private:
void Shout();
static constexpr const char* shoutAudio = "Woof!";
};
DogToy.cpp
#include "DogToy.hpp"
#include <iostream>
DogToy::DogToy(const std::string& name0, const std::string& material0, const std::string& musicAudio0) : Toy(name0,material0,musicAudio0)
{
type = ToyType::DOG;
}
void DogToy::start()
{
std::cout << "Hi! My name is " << name << ". Let's play! ";
Shout();
std::cout << std::endl;
}
void DogToy::act()
{
std::cout << name << " is wagging tail!\n";
}
void DogToy::playAudio()
{
std::cout << "Playing: " << musicAudio << '\n';
}
void DogToy::shutdown()
{
std::cout << "Bye! ";
Shout();
std::cout << '\n';
}
void DogToy::Shout()
{
std::cout << shoutAudio;
}
CatToy.hpp
#pragma once
#include "Toy.hpp"
class CatToy : public Toy
{
public:
CatToy(const std::string& name0 = "FriendCat", const std::string& material0 = "Cotton", const std::string& musicAudio = "DefaultCatSong");
void start() override;
void act() override;
void playAudio() override;
void shutdown() override;
private:
void Shout();
static constexpr const char* shoutAudio = "Meow!";
};
CatToy.cpp
#include "CatToy.hpp"
#include <iostream>
CatToy::CatToy(const std::string& name0, const std::string& material0, const std::string& musicAudio0) : Toy(name0, material0, musicAudio0)
{
type = ToyType::CAT;
}
void CatToy::start()
{
std::cout << "Hi! My name is " << name << ". Let's play! ";
Shout();
std::cout << std::endl;
}
void CatToy::act()
{
std::cout << name << " is licking its fur!\n";
}
void CatToy::playAudio()
{
std::cout << "Playing: " << musicAudio << '\n';
}
void CatToy::shutdown()
{
std::cout << "Bye! ";
Shout();
std::cout << '\n';
}
void CatToy::Shout()
{
std::cout << shoutAudio;
}
BearToy.hpp
#pragma once
#include "Toy.hpp"
class BearToy : public Toy
{
public:
BearToy(const std::string& name0 = "FriendBear", const std::string& material0 = "Cotton", const std::string& musicAudio = "DefaultBearSong");
void start() override;
void act() override;
void playAudio() override;
void shutdown() override;
};
BearToy.cpp
#include "BearToy.hpp"
#include <iostream>
BearToy::BearToy(const std::string& name0, const std::string& material0, const std::string& musicAudio0) : Toy(name0, material0, musicAudio0)
{
type = ToyType::BEAR;
}
void BearToy::start()
{
std::cout << "Hi! My name is " << name << ". Let's play! ";
std::cout << std::endl;
}
void BearToy::act()
{
std::cout << name << " is waving its hands!\n";
}
void BearToy::playAudio()
{
std::cout << "Playing: " << musicAudio << '\n';
}
void BearToy::shutdown()
{
std::cout << "Bye! ";
std::cout << '\n';
}
ToyFactory.hpp
#include "Toy.hpp"
#include "BearToy.hpp"
#include "DogToy.hpp"
#include "CatToy.hpp"
#include <string>
#include <vector>
class ToyFactory
{
public:
ToyFactory(const std::string& title0);
~ToyFactory();
void display() const;
void act() const;
void play() const;
void addToy(const std::string& type0 = "unknowntoy", const std::string& name0 = "Default Name",
const std::string& material0 = "Default Material", const std::string& musicAudio0 = "DefaultSong");
void delToy(const std::string& target);
private:
std::string title;
std::vector<Toy*> toys;
};
ToyType str_to_ToyType(const std::string& s);
ToyFactory.cpp
#include "ToyFactory.hpp"
#include <algorithm>
#include <cctype>
#include <iostream>
ToyFactory::ToyFactory(const std::string& title0) : title{title0} { }
ToyFactory::~ToyFactory()
{
for (Toy* t : toys)
delete t;
}
ToyType str_to_ToyType(const std::string& s)
{
std::string t = s;
std::transform(s.begin(), s.end(), t.begin(), [](unsigned char c) {return std::tolower(c); });
if (t == "dog")
return ToyType::DOG;
if (t == "cat")
return ToyType::CAT;
if (t == "bear")
return ToyType::BEAR;
return ToyType::UNKNOWNTOY;
}
void ToyFactory::display() const
{
std::cout << "Toys Informaiton: \n";
if (toys.size() == 0)
{
std::cout << "factory is empty!";
return;
}
Toy* index = toys.at(0);
for (int i = 0; i < toys.size(); i++)
{
index = toys.at(i);
index->displayInfo();
}
}
void ToyFactory::act() const
{
for (auto i : toys)
i->act();
}
void ToyFactory::play() const
{
for (auto i : toys)
i->playAudio();
}
void ToyFactory::addToy(const std::string& type0, const std::string& name0, const std::string& material0, const std::string& musicAudio0)
{
for (Toy* t : toys)
{
if (t->getName() == name0)
{
std::cerr << name0 << " has existed!\n";
return;
}
}
Toy* newToy;
switch (str_to_ToyType(type0))
{
case ToyType::DOG:
newToy = new DogToy(name0, material0, musicAudio0);
break;
case ToyType::CAT:
newToy = new CatToy(name0, material0, musicAudio0);
break;
case ToyType::BEAR:
newToy = new BearToy(name0, material0, musicAudio0);
break;
default:
std::cerr << "Fail To Add Toy: " << name0 << " Unknown Type\n";
return;
}
toys.push_back(newToy);
std::cout << "Success To Add Toy: " << name0 << '\n';
}
void ToyFactory::delToy(const std::string& target)
{
for (auto it = toys.begin(); it != toys.end(); it++)
{
if (*it && (*it)->getName() == target)
{
delete* it;
toys.erase(it);
std::cout << "Del Success\n";
return;
}
}
std::cerr << "target not found";
}
main.cpp
#include <iostream>
#include <string>
#include "ToyFactory.hpp"
void test1()
{
ToyFactory factory("My Toy Factory");
factory.addToy("cat", "kitty", "cotton", "MorningMeow");
factory.addToy("DOG", "Bruce", "Plastic", "Erica");
factory.addToy("Bear", "Teddy", "Cotton", "Hotel California");
factory.display();
factory.act();
factory.play();
factory.delToy("kitty");
factory.display();
}
int main()
{
test1();
}
运行测试结果
浙公网安备 33010602011771号