Comprehensive Exercises#

Exercise 1: Graphics Drawing System (Inheritance + Polymorphism + Smart Pointer + STL)#

Requirement Description Simulate the core module of a graphics editing software, implement functions for drawing, area calculation, and management of various basic graphics, and require flexible expansion of graphic types.

Core Function Definitions

Define an abstract base class Shape (pure virtual class), including:
- Protected member: string colour.
- Pure virtual functions:
  - draw() —output drawing information
  - calcArea() —calculate area and return a double
- Virtual destructor (to ensure proper release of derived class resources).

1
//
2
// Created by 不死鸟Anka on 2025/12/2.
3
//
4

5
#ifndef CPP_SHAPE_H
6
#define CPP_SHAPE_H
7

8
#include <string>
9

10
class Shape
11
{
12
protected:
13
    std::string colour;
14
public:
15
    Shape() = default;
16
    explicit Shape(const std::string &colour_) : colour(colour_) {}
17

18
    // Virtual destructor to ensure proper cleanup in derived classes
19
    virtual ~Shape() = default;
20

21
    // Pure virtual: output drawing information
22
    virtual void draw() const = 0;
23

24
    // Pure virtual: calculate area and return as double
25
    virtual double calcArea() const = 0;
26

27
    // Small utilities
28
    const std::string &getColour() const { return colour; }
29
    void setColour(const std::string &c) { colour = c; }
30
};
31

32
#endif //CPP_SHAPE_H

Derive 3 specific graphic classes:
- Circle: Contains a radius member; area formula: π×r² (π = 3.14159).
- Rectangle: Contains length and width members; area formula: length × width.
- Triangle: Contains base and height members; area formula: (base × height) ÷ 2. All derived classes must call the base class constructor through an initialization list and override the pure virtual functions.

1
#ifndef CPP_CIRCLE_H
2
#define CPP_CIRCLE_H
3

4
#include "Shape.h"
5
#include <string>
6

7
class Circle : public Shape {
8
private:
9
    double radius{0.0};
10
public:
11
    Circle() = default;
12
    Circle(const std::string &colour_, double r) : Shape(colour_), radius(r) {}
13

14
    // Override draw to output drawing information
15
    void draw() const override;
16

17
    // Override calcArea to compute area of circle (pi * r^2)
18
    double calcArea() const override;
19
};
20

21
#endif //CPP_CIRCLE_H

1
#include "Circle.h"
2
#include <iostream>
3

4
static constexpr double PI = 3.14159;
5

6
void Circle::draw() const {
7
    std::cout << "Drawing Circle: colour=" << colour << ", radius=" << radius << '\n';
8
}
9

10
double Circle::calcArea() const {
11
    return PI * radius * radius;
12
}

1
#ifndef CPP_RECTANGLE_H
2
#define CPP_RECTANGLE_H
3

4
#include "Shape.h"
5

6
class Rectangle : public Shape {
7
private:
8
    double length;
9
    double width;
10
public:
11
    Rectangle() = default;
12
    Rectangle(const std::string &colour_, double length_, double width_) : Shape(colour_), length(length_), width(width_) {}
13

14
    void draw() const override;
15
    double calcArea() const override;
16
};
17

18
#endif //CPP_RECTANGLE_H

1
#include "Rectangle.h"
2
#include <iostream>
3

4
void Rectangle::draw() const {
5
    std::cout << "Drawing Rectangle: colour=" << colour << ", length=" << length << ", width=" << width << '\n';
6
}
7

8
double Rectangle::calcArea() const {
9
    return length * width;
10
}

1
#ifndef CPP_TRIANGLE_H
2
#define CPP_TRIANGLE_H
3

4
#include "Shape.h"
5

6
class Triangle : public Shape {
7
private:
8
    double base;
9
    double height;
10
public:
11
    Triangle() = default;
12
    Triangle(const std::string &colour_, double base_, double height_) : Shape(colour_), base(base_), height(height_) {}
13

14
    void draw() const override;
15
    double calcArea() const override;
16
};
17

18
#endif //CPP_TRIANGLE_H

1
#include "Triangle.h"
2
#include <iostream>
3

4
void Triangle::draw() const {
5
    std::cout << "Drawing Triangle: colour=" << colour << ", base=" << base << ", height=" << height << '\n';
6
}
7

8
double Triangle::calcArea() const {
9
    return (base * height) / 2.0;
10
}

Design the GraphicsManager class, use list to store graphic pointers of type unique_ptr<Shape>, and implement the following:
- Add graphics : addShape(unique_ptr<Shape> shape)
- Sort the graphic list in descending order of area.
- Calculate the total area of all graphics.
- Batch draw all graphics (call the draw() method of each graphic).

1
#ifndef CPP_GRAPHICS_MANAGER_H
2
#define CPP_GRAPHICS_MANAGER_H
3

4
#include "Shape.h"
5
#include <list>
6
#include <memory>
7

8
class GraphicsManager {
9
private:
10
    std::list<std::unique_ptr<Shape>> shapes;
11

12
public:
13
    GraphicsManager() = default;
14
    ~GraphicsManager() = default;
15

16
    // Add a shape (takes ownership)
17
    void addShape(std::unique_ptr<Shape> shape);
18

19
    // Sort shapes in descending order of area
20
    void sortByAreaDesc();
21

22
    // Calculate total area of all shapes
23
    double totalArea() const;
24

25
    // Batch draw all shapes (calls draw() on each)
26
    void drawAll() const;
27

28
    // Utility: number of shapes
29
    std::size_t count() const { return shapes.size(); }
30
};
31

32
#endif //CPP_GRAPHICS_MANAGER_H

1
#include "GraphicsManager.h"
2
#include <algorithm>
3

4
void GraphicsManager::addShape(std::unique_ptr<Shape> shape) {
5
    // shapes.push_back(std::move(shape));
6
    if (shapes.empty()) {
7
        shapes.push_back(std::move(shape));
8
    } else {
9
        auto it = shapes.begin();
10
        while (it != shapes.end() && (*it)->calcArea() > shape->calcArea()) {
11
            ++it;
12
        }
13
        shapes.insert(it, std::move(shape));
14
    }
15
}
16

17
void GraphicsManager::sortByAreaDesc() {
18
    shapes.sort([](const std::unique_ptr<Shape> &a, const std::unique_ptr<Shape> &b) {
19
        return a->calcArea() > b->calcArea();
20
    });
21
}
22

23
double GraphicsManager::totalArea() const {
24
    double sum = 0.0;
25
    for (const auto &s : shapes) {
26
        sum += s->calcArea();
27
    }
28
    return sum;
29
}
30

31
void GraphicsManager::drawAll() const {
32
    for (const auto &s : shapes) {
33
        s->draw();
34
    }
35
}

Simulate usage in the main function: Create at least 5 graphics of different types, and complete sorting, statistics, and drawing through the manager.

1
#include <iostream>
2
#include <memory>
3
#include <vector>
4

5
#include "Circle.h"
6
#include "Rectangle.h"
7
#include "Triangle.h"
8
#include "GraphicsManager.h"
9

10
int main() {
11
    GraphicsManager gm;
12

13
    // std::list<std::unique_ptr<Shape>> shapes;
14
    // Circle c0("test", 1.0);
15
    // std::unique_ptr<Shape> c1(&c0);
16
    // gm.addShape(std::move(c1));
17
    // shapes.push_back(std::move(c1));
18
    // c0.draw();
19
    // c1->draw();
20

21
    // Create at least 5 graphics of mixed types
22
    gm.addShape(std::make_unique<Circle>("red", 2.5));        // area ~19.6349
23
    gm.addShape(std::make_unique<Rectangle>("blue", 4.0, 3.0)); // area 12
24
    gm.addShape(std::make_unique<Triangle>("green", 6.0, 2.0)); // area 6
25
    gm.addShape(std::make_unique<Circle>("yellow", 1.2));    // area ~4.523424
26
    gm.addShape(std::make_unique<Rectangle>("magenta", 2.5, 5.0)); // area 12.5
27
    gm.addShape(std::make_unique<Triangle>("cyan", 3.0, 4.0)); // area 6
28

29
    std::cout << "Shapes created: " << gm.count() << "\n";
30
    double total = gm.totalArea();
31
    std::cout << "Total area (unsorted): " << total << "\n";
32
    if (gm.count() > 0) {
33
        std::cout << "Average area: " << (total / static_cast<double>(gm.count())) << "\n";
34
    }
35

36
    std::cout << "\nDrawing (unsorted):\n";
37
    gm.drawAll();
38

39
    // Sort shapes by area descending
40
    gm.sortByAreaDesc();
41

42
    std::cout << "\nDrawing (sorted by area desc):\n";
43
    gm.drawAll();
44

45
    std::cout << "\nTotal area (after sort): " << gm.totalArea() << "\n";
46
    if (gm.count() > 0) {
47
        std::cout << "Average area (after sort): " << (gm.totalArea() / static_cast<double>(gm.count())) << "\n";
48
    }
49

50
    return 0;
51
}

Technical Requirements

Must implement polymorphic calls through base class pointers; direct calls to derived class methods are prohibited.
The ownership of graphic objects is unique; only unique_ptr is allowed for management.
Retain 2 decimal places when outputting the area calculation results.

Exercise 2: General Data Filter (Template + STL Algorithm)#

Implement a generic template class that uses STL list as the underlying storage container. The class only supports basic data types (int, double) and focuses on a single core capability: sorting the data stored in the list in ascending order (from smallest to largest).

Core Requirements

Template Class Definition: ListSorter<T>
Define a class template ListSorter<T> (where T is restricted to int or double) with the following structure:

Private Member:
list<T> dataList: A list container to store the input basic-type data (no other storage containers are allowed).

Public Member Functions

Function	Description
`void loadData(const std::list<T>& input)`	Copy the input `list<T>` data into the private dataList container (overwrite existing data if any).
`void sortAscending()`	Sort the elements in dataList in ascending order (smallest to largest). Note: You may use the list member function `sort()`.
`void printData(const std::string& title) const`	Traverse the private `dataList` and print all elements in a readable format (with the given title to distinguish original/sorted data).

1
//
2
// Created by 不死鸟Anka on 2025/12/2.
3
//
4

5
#ifndef CPP_LISTSORTER_H
6
#define CPP_LISTSORTER_H
7

8
#include <list>
9
#include <string>
10
#include <iostream>
11
#include <type_traits>
12

13
template<typename T>
14
class ListSorter
15
{
16
    static_assert(std::is_same<T, int>::value || std::is_same<T, double>::value,
17
                  "ListSorter only supports int and double.");
18

19
private:
20
    std::list<T> dataList;
21

22
public:
23
    // Copy input data into internal list (overwrite existing data)
24
    void loadData(const std::list<T>& input) {
25
        dataList = input;
26
    }
27

28
    // Sort internal list in ascending order
29
    void sortAscending() {
30
        dataList.sort();
31
    }
32

33
    // Print the contents with a title. Elements separated by single spaces.
34
    void printData(const std::string& title) const {
35
        std::cout << title << ":\n";
36
        if (dataList.empty()) {
37
            std::cout << "(empty)\n\n";
38
            return;
39
        }
40

41
        for (auto it = dataList.cbegin(); it != dataList.cend(); ++it) {
42
            std::cout << *it;
43
            auto nextIt = it;
44
            ++nextIt;
45
            if (nextIt != dataList.cend()) std::cout << " ";
46
        }
47
        std::cout << "\n\n";
48
    }
49
};
50

51
#endif //CPP_LISTSORTER_H

Test Requirements Implement a main() function to test the ListSorter<T> class with two sets of data, and output results in the specified format:
1. Test Case 1: Process std::list<int>
  - Input data: {9, 3, 7, 1, 8, 2, 10, 5, 4, 6}
  - Load the data into ListSorter<int>.
  - Print the original unsorted data (title: “Original int list”).
  - Call sortAscending() to sort the data.
  - Print the sorted data (title: “Sorted int list (ascending)”).
2. Test Case 2: Process std::list<double>
  - Input data: {5.8, 2.3, 9.1, 1.7, 7.4, 3.9, 8.2, 4.5}
  - Load the data into ListSorter<double>.
  - Print the original unsorted data (title: “Original double list”).
  - Call sortAscending() to sort the data.
  - Print the sorted data (title: “Sorted double list (ascending)”).

1
#include "ListSorter.h"
2
#include <list>
3

4
int main() {
5
    // Test Case 1: int list
6
    ListSorter<int> intSorter;
7
    std::list<int> intData = {9, 3, 7, 1, 8, 2, 10, 5, 4, 6};
8
    intSorter.loadData(intData);
9
    intSorter.printData("Original int list");
10
    intSorter.sortAscending();
11
    intSorter.printData("Sorted int list (ascending)");
12

13
    // Test Case 2: double list
14
    ListSorter<double> doubleSorter;
15
    std::list<double> doubleData = {5.8, 2.3, 9.1, 1.7, 7.4, 3.9, 8.2, 4.5};
16
    doubleSorter.loadData(doubleData);
17
    doubleSorter.printData("Original double list");
18
    doubleSorter.sortAscending();
19
    doubleSorter.printData("Sorted double list (ascending)");
20

21
    return 0;
22
}