Anka

Announcement

Welcome to my blog!

Learn More

1351 字

7 分钟

Software Development with C and Cpp Week6 Lecture

2025-11-03

Software Development with C and Cpp

无标签

Consolidation of Coursework1#

Class test 1#

All questions are related to the coursework 1, in terms of
- the features of the OO programming
- the implementation of creating a class with proper structure
- the implementation of methods with proper parameters
- the proper syntax
- the proper logic

Two hours, book-closed test this Wednesday, 2-4 PM
It weighs 50% of all coursework parts, as well as 25% of the whole module.

	Components	Weight
Section A	MCQ (Multiple Choice Question)	5×5
Section B	Find and fix bugs	6×2
Section B	Programming	5+8+15+20
Section C	Short answer question	5×10

Question example#

MCQ (Multiple Choice Question)#

Which of the following statements is a valid reason to use a virtual destructor in a base class?
A. To allow the base class to be instantiated as an object.
B. To force derived classes to explicitly override the destructor.
C. To eliminate compilation warnings related to inheritance.
D. To improve the runtime efficiency of destructor calls in the derived class.
✅E. To ensure that the derived class destructor is called when deleting a derived class object through a base class pointer.

Find and fix bugs#

There are 2 bugs in the following segment of code.
Please write down the line numbers and give the corresponding correct code.

1
class Book {
2
    protected:
3
        string bookld;
4
        string title;
5
        bool isBorrowed;
6
    private:
7
        void Book(string bid, string t, int y) : bookld (bid), title(t), isBorrowed(false) {}
8
        virtual ~Book() {}
9
        string getBookid() const { return bookld; }
10
        string getTitle() const { return title; }
11
        bool getlsBorrowed) const { return isBorrowed; }
12
        bool setBorrowed (bool borrowed) { isBorrowed = borrowed; }
13
        virtual void displayInfo() {...};
14
};

Programming#

There is a virtual method displayInfo() defined in the class provided in the above example, but without a detailed implementation.
- Please complete the implementation of the method to make it print all book details (bookId, title, and borrowing status).

1
void Book::displayInfo() {
2
    std::cout << "[Book]" << std::endl;
3
    std::cout << "UUID: " << getUUID() << std::endl;
4
    std::cout << "Book ID: " << getBookId() << std::endl;
5
    std::cout << "Title: " << getTitle() << std::endl;
6
    std::cout << "Author: " << author << std::endl;
7
    std::cout << "Publish Year: " << publishYear << std::endl;
8
    std::cout << "Borrowed: " << (getIsBorrowed() ? "Yes" : "No") << std::endl;
9
    if (getIsBorrowed() && borrower) {
10
        std::cout << "Borrower: ";
11
        borrower->displayInfo();
12
        std::cout << "Borrow Date: " << borrowDate.toString() << std::endl;
13
    }
14
}

Please create a derived class Novel, which inherits from the base class Book.
- class Novel has one new data member: genre, which represents the style of the novel, such as Mystery, Romance,.etc.
- override the displayInfo() method to print all novel details.

1
class Novel : public Book {
2
private:
3
    std::string genre;
4
public:
5
    Novel(std::string uid, std::string bid, std::string t, std::string a, std::string p, int y, Date d, std::string g)
6
        : Book(uid, bid, t, a, p, y, d), genre(g) {}
7
    std::string getGenre() const { return genre; }
8
    void setGenre(const std::string& g) { genre = g; }
9
    std::string getCategory() override;
10
    void displayInfo() override;
11
};
12
void Novel::displayInfo() {
13
    std::cout << "[Novel]" << std::endl;
14
    std::cout << "UUID: " << getUUID() << std::endl;
15
    std::cout << "Book ID: " << getBookId() << std::endl;
16
    std::cout << "Title: " << getTitle() << std::endl;
17
    std::cout << "Author: " << author << std::endl;
18
    std::cout << "Publish Year: " << publishYear << std::endl;
19
    std::cout << "Genre: " << genre << std::endl;
20
    std::cout << "Borrowed: " << (getIsBorrowed() ? "Yes" : "No") << std::endl;
21
    if (getIsBorrowed() && borrower) {
22
        std::cout << "Borrower: ";
23
        borrower->displayInfo();
24
        std::cout << "Borrow Date: " << borrowDate.toString() << std::endl;
25
    }
26
}

Short answer question#

Please elaborate on the core features of the Object-Oriented programming language.

Object-Oriented Programming (OOP) is a paradigm that organizes software design around objects—entities that bundle both data (attributes or fields) and behavior (methods or functions). The goal is to model real-world systems in a more modular, reusable, and maintainable way. The core features (or principles) of OOP are typically summarized as Encapsulation, Abstraction, Inheritance, and Polymorphism.

🔹 1. Encapsulation#

Encapsulation means wrapping data (variables) and functions (methods) into a single unit, typically a class.
It also allows data hiding, meaning internal details of the class are protected from external access.
Example:

1
#include <iostream>
2
using namespace std;
3

4
class BankAccount {
5
private:
6
    double balance;  // Private data member – cannot be accessed directly outside the class
7

8
public:
9
    // Constructor
10
    BankAccount(double initialBalance) {
11
        balance = (initialBalance > 0) ? initialBalance : 0;
12
    }
13

14
    // Public method to modify data safely
15
    void deposit(double amount) {
16
        if (amount > 0) balance += amount;
17
    }
18

19
    // Public method to access data safely
20
    double getBalance() const {
21
        return balance;
22
    }
23
};
24

25
int main() {
26
    BankAccount account(100.0);
27
    account.deposit(50.0);
28
    cout << "Current balance: $" << account.getBalance() << endl;
29
    return 0;
30
}

✅ Key idea: The balance is encapsulated — only accessible and modifiable through controlled public methods.

🔹 2. Abstraction#

Abstraction focuses on showing only the essential features of an object while hiding the implementation details.
In C++, this is often achieved using abstract classes (classes with pure virtual functions).
Example:

1
#include <iostream>
2
using namespace std;
3

4
// Abstract base class
5
class Shape {
6
public:
7
    virtual void draw() = 0;  // Pure virtual function (no implementation)
8
};
9

10
// Derived class
11
class Circle : public Shape {
12
public:
13
    void draw() override {
14
        cout << "Drawing a circle" << endl;
15
    }
16
};
17

18
int main() {
19
    Shape* shape = new Circle();  // Base class pointer to derived class object
20
    shape->draw();
21
    delete shape;
22
    return 0;
23
}

✅ Key idea: The user interacts with Shape through the abstract interface, without worrying about how draw() is implemented.

🔹 3. Inheritance#

Inheritance allows a class (child or derived class) to inherit properties and behaviors from another class (parent or base class).
This promotes code reuse and logical hierarchy.
Example:

1
#include <iostream>
2
using namespace std;
3

4
class Animal {
5
public:
6
    void eat() {
7
        cout << "This animal eats food." << endl;
8
    }
9
};
10

11
class Dog : public Animal {  // Dog inherits from Animal
12
public:
13
    void bark() {
14
        cout << "Dog barks." << endl;
15
    }
16
};
17

18
int main() {
19
    Dog d;
20
    d.eat();   // Inherited from Animal
21
    d.bark();  // Defined in Dog
22
    return 0;
23
}

✅ Key idea: The Dog class reuses the behavior from Animal while adding its own (bark()).

🔹 4. Polymorphism#

Polymorphism means “many forms” — allowing the same function call to behave differently depending on the object type.
There are two types in C++:

a) Compile-Time Polymorphism (Function Overloading)#

Multiple functions with the same name but different parameter types or counts.

1
#include <iostream>
2
using namespace std;
3

4
class Printer {
5
public:
6
    void print(int i) { cout << "Printing int: " << i << endl; }
7
    void print(double d) { cout << "Printing double: " << d << endl; }
8
    void print(string s) { cout << "Printing string: " << s << endl; }
9
};
10

11
int main() {
12
    Printer p;
13
    p.print(5);
14
    p.print(3.14);
15
    p.print("Hello");
16
    return 0;
17
}

b) Runtime Polymorphism (Function Overriding with Virtual Functions)#

When a derived class overrides a virtual function from the base class, and the correct function is called dynamically at runtime.

1
#include <iostream>
2
using namespace std;
3

4
class Animal {
5
public:
6
    virtual void makeSound() {  // Virtual function
7
        cout << "Some generic sound" << endl;
8
    }
9
};
10

11
class Cat : public Animal {
12
public:
13
    void makeSound() override {  // Override base method
14
        cout << "Meow" << endl;
15
    }
16
};
17

18
int main() {
19
    Animal* a = new Cat();  // Base pointer to derived object
20
    a->makeSound();         // Calls Cat’s version at runtime
21
    delete a;
22
    return 0;
23
}

✅ Key idea: Even though a is of type Animal*, the Cat version of makeSound() runs — this is dynamic dispatch.

🧩 Summary Table#

OOP Feature	Description	C++ Mechanism	Example Keyword/Concept
Encapsulation	Hiding data and providing controlled access	Access specifiers	`private`, `public`
Abstraction	Hiding implementation details, exposing interface	Abstract classes, pure virtual functions	`virtual void draw() = 0;`
Inheritance	Reusing code from base classes	Class inheritance	`class Dog : public Animal`
Polymorphism	Same interface, different behavior	Overloading & Overriding	`virtual`, function overloading

Note#

If you complete the implementation of coursework 1 by yourself, it is not necessary to worry about it.
Read the questions carefully.
Try to write the code with good handwriting.
You must submit the project source code file to the student’s website by this Friday, 16:00. Otherwise, you will get zero, even if you got a good performance on the class test 1.