首页手记 C++面向对象项目实战入门教程

C++面向对象项目实战入门教程

标签：

C++ 设计模式

概述

本文将带你深入了解C++面向对象编程的基础概念和实践方法，包括类与对象、封装、继承、多态等核心内容。通过实际项目案例，你将学习如何设计和实现一个简单的图书管理系统，从而掌握面向对象项目实战的关键技能。文中还提供了调试技巧和优化建议，帮助你提升代码质量和性能。

C++面向对象项目实战入门教程

1. C++面向对象基础概念

1.1 类与对象

在C++中，类（Class）是一种用户自定义的数据类型，它封装了数据（成员变量）和操作这些数据的方法（成员函数）。对象（Object）是类的实例，每个对象都有自己的属性（数据）和行为（方法）。

定义类：

class Person {
public:
    // 成员变量
    std::string name;
    int age;

    // 构造函数
    Person(std::string n, int a) : name(n), age(a) {}

    // 成员函数
    void introduce() {
        std::cout << "My name is " << name << ", and I am " << age << " years old." << std::endl;
    }
};

创建对象：

int main() {
    Person person1("Alice", 25);
    person1.introduce(); // 输出：My name is Alice, and I am 25 years old.
}

1.2 封装（Encapsulation）

封装是将数据和操作这些数据的方法捆绑在一起，并对外隐藏内部实现细节的一种机制。C++通过访问控制符（public, private, protected）实现封装。

封装示例：

class BankAccount {
private:
    std::string accountNumber;
    double balance;

public:
    BankAccount(std::string accNum, double initialBalance) : accountNumber(accNum), balance(initialBalance) {}

    void deposit(double amount) {
        balance += amount;
    }

    void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            std::cout << "Insufficient funds." << std::endl;
        }
    }

    double getBalance() const {
        return balance;
    }
};

1.3 继承（Inheritance）

继承是面向对象编程中的一个关键特性，它允许一个类继承另一个类的属性和方法。子类（派生类）可以重用和扩展父类（基类）的功能。

继承示例：

class Animal {
public:
    void eat() {
        std::cout << "Animal is eating." << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << "Dog is barking." << std::endl;
    }
};

1.4 多态（Polymorphism）

多态是指允许不同类的对象可以通过相同接口进行调用，从而实现相同的接口不同的实现。

多态示例：

class Animal {
public:
    virtual void makeSound() const = 0; // 抽象方法
};

class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Dog is barking." << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Cat is meowing." << std::endl;
    }
};

void makeAnimalSound(const Animal& animal) {
    animal.makeSound();
}

int main() {
    Dog dog;
    Cat cat;

    makeAnimalSound(dog); // 输出：Dog is barking.
    makeAnimalSound(cat); // 输出：Cat is meowing.
}

1.5 抽象类与接口

抽象类是一种不能实例化的类，它只能作为其他类的基类。抽象类通常包含至少一个纯虚函数（没有实现的虚函数），用来声明抽象方法。

抽象类示例：

class Shape {
public:
    virtual double area() const = 0; // 抽象方法
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    double area() const override {
        return M_PI * radius * radius;
    }
};

接口是一种特殊的抽象类，它只包含纯虚函数，没有数据成员。接口用于定义多重继承的契约。

接口示例：

class Drawable {
public:
    virtual ~Drawable() = default;
    virtual void draw() const = 0; // 抽象方法
};

class Rectangle : public Drawable {
private:
    double width, height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    void draw() const override {
        std::cout << "Drawing a rectangle with width " << width << " and height " << height << "." << std::endl;
    }
};

2. C++面向对象编程实践

2.1 定义类和成员变量

定义一个简单的类 Person，包含名字和年龄两个成员变量。

class Person {
public:
    std::string name;
    int age;

    Person(std::string n, int a) : name(n), age(a) {}
};

2.2 成员函数的实现

成员函数可以实现类的行为，包括数据操作和逻辑处理。

class Person {
public:
    std::string name;
    int age;

    Person(std::string n, int a) : name(n), age(a) {}

    void introduce() {
        std::cout << "My name is " << name << ", and I am " << age << " years old." << std::endl;
    }
};

2.3 构造函数与析构函数

构造函数用于初始化对象，析构函数用于释放资源。

class Person {
public:
    std::string name;
    int age;

    Person(std::string n, int a) : name(n), age(a) {}

    ~Person() {
        std::cout << "Person " << name << " destroyed." << std::endl;
    }

    void introduce() {
        std::cout << "My name is " << name << ", and I am " << age << " years old." << std::endl;
    }
};

2.4 静态成员变量与成员函数

静态成员变量和静态成员函数属于整个类，而不是单个对象。

class Counter {
private:
    static int count;

public:
    Counter() {
        count++;
    }

    static int getCount() {
        return count;
    }

    ~Counter() {
        count--;
    }
};

int Counter::count = 0;

int main() {
    Counter c1;
    Counter c2;
    std::cout << "Count: " << Counter::getCount() << std::endl; // 输出：Count: 2
}

3. 面向对象设计原则

3.1 单一职责原则（SRP）

单一职责原则要求一个类只有一个职责。如果一个类承担了多个职责，就容易导致设计上的混乱和维护困难。

class Account {
public:
    void deposit(double amount) {
        // 存款逻辑
    }

    void withdraw(double amount) {
        // 取款逻辑
    }

    void printStatement() {
        // 打印账单逻辑
    }
};

class ReportGenerator {
public:
    void generateReport() {
        // 生成报告的逻辑
    }
};

3.2 开闭原则（OCP）

开闭原则要求软件实体应该是可扩展的，但不可修改的。即在不修改已有源码的基础上，增加新的功能。

class Animal {
public:
    virtual void makeSound() const = 0; // 模板方法
};

class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Dog barks." << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Cat meows." << std::endl;
    }
};

3.3 里氏替换原则（LSP）

里氏替换原则要求子类能替换父类，且程序在运行时不会发现任何错误。也就是说，子类的对象可以在父类对象出现的地方代替父类对象，而不会导致程序错误。

class Shape {
public:
    virtual double area() const = 0;
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    double area() const override {
        return M_PI * radius * radius;
    }
};

3.4 接口隔离原则（ISP）

接口隔离原则要求接口应该尽量细化，每个接口应该只定义客户端需要的方法，这样可以使接口更加简单，更易于使用。

class Drawable {
public:
    virtual ~Drawable() = default;
    virtual void draw() const = 0; // 抽象方法
};

class Circle : public Drawable {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    void draw() const override {
        std::cout << "Drawing a circle with radius: " << radius << "." << std::endl;
    }
};

3.5 依赖倒置原则（DIP）

依赖倒置原则要求高层模块不应该依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

class Logger {
public:
    virtual void log(const std::string& message) = 0;
};

class ConsoleLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::cout << "Log: " << message << std::endl;
    }
};

class FileLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::ofstream file("log.txt", std::ios_base::app);
        file << "Log: " << message << std::endl;
    }
};

class Application {
private:
    Logger* logger;

public:
    Application(Logger* l) : logger(l) {}

    void process() {
        logger->log("Processing...");
    }
};

4. 实战项目规划

4.1 选择项目主题

选择一个实际应用的主题，比如一个简单的图书管理系统。这个系统需要能够添加、删除、查找和显示图书信息。

4.2 分析需求

需求分析包括明确系统需要处理的任务和功能。对于图书管理系统，具体需求可以是：

添加新图书
删除已有的图书
根据书名或作者查找图书
显示所有图书信息

4.3 设计类图

设计类图来可视化各个类之间的关系。对于图书管理系统，设计的类可以包括 Book 和 Library。

+-------------------+
|       Book        |
+-------------------+
| + title: string   |
| + author: string  |
| + pages: int      |
| + publisher: string |
| + publishYear: int  |
| + id: int         |
| + setId(int)      |
| + getId(): int    |
| + setTitle(string) |
| + getTitle(): string |
| + setAuthor(string) |
| + getAuthor(): string |
| + setPages(int)    |
| + getPages(): int  |
| + setPublisher(string) |
| + getPublisher(): string |
| + setPublishYear(int)  |
| + getPublishYear(): int |
+-------------------+
         ^
         |
+-------------------+
|     Library       |
+-------------------+
| + books: vector<Book> |
| + addBook(Book)   |
| + removeBook(int)  |
| + findBookById(int): Book |
| + findBookByTitle(string): Book |
| + findAll(): vector<Book> |
+-------------------+

4.4 编写代码

根据设计的类图编写代码实现图书管理系统。

首先，定义 Book 类：

class Book {
private:
    std::string title;
    std::string author;
    int pages;
    std::string publisher;
    int publishYear;
    int id;

public:
    Book(int id, std::string title, std::string author, int pages, std::string publisher, int publishYear)
        : id(id), title(title), author(author), pages(pages), publisher(publisher), publishYear(publishYear) {}

    int getId() const { return id; }
    void setId(int id) { this->id = id; }

    std::string getTitle() const { return title; }
    void setTitle(const std::string& title) { this->title = title; }

    std::string getAuthor() const { return author; }
    void setAuthor(const std::string& author) { this->author = author; }

    int getPages() const { return pages; }
    void setPages(int pages) { this->pages = pages; }

    std::string getPublisher() const { return publisher; }
    void setPublisher(const std::string& publisher) { this->publisher = publisher; }

    int getPublishYear() const { return publishYear; }
    void setPublishYear(int publishYear) { this->publishYear = publishYear; }

    void display() const {
        std::cout << "Book ID: " << id << std::endl;
        std::cout << "Title: " << title << std::endl;
        std::cout << "Author: " << author << std::endl;
        std::cout << "Pages: " << pages << std::endl;
        std::cout << "Publisher: " << publisher << std::endl;
        std::cout << "Publish Year: " << publishYear << std::endl;
    }
};

其次，定义 Library 类：

class Library {
private:
    std::vector<Book> books;

public:
    void addBook(const Book& book) {
        books.push_back(book);
    }

    void removeBook(int id) {
        books.erase(std::remove_if(books.begin(), books.end(), [&](const Book& b) { return b.getId() == id; }), books.end());
    }

    Book* findBookById(int id) {
        for (const Book& book : books) {
            if (book.getId() == id) {
                return const_cast<Book*>(&book);
            }
        }
        return nullptr;
    }

    Book* findBookByTitle(const std::string& title) {
        for (const Book& book : books) {
            if (book.getTitle() == title) {
                return const_cast<Book*>(&book);
            }
        }
        return nullptr;
    }

    std::vector<Book> findAll() const {
        return books;
    }

    void displayAll() const {
        for (const Book& book : books) {
            book.display();
            std::cout << "------------------------" << std::endl;
        }
    }
};

最后，实现主函数：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

int main() {
    Library library;

    Book book1(1, "The Great Gatsby", "F. Scott Fitzgerald", 180, "Scribner", 1925);
    Book book2(2, "To Kill a Mockingbird", "Harper Lee", 283, "J. B. Lippincott & Co.", 1960);

    library.addBook(book1);
    library.addBook(book2);

    library.displayAll();

    library.removeBook(1);

    library.displayAll();

    Book* foundBook = library.findBookByTitle("To Kill a Mockingbird");
    if (foundBook) {
        foundBook->display();
    } else {
        std::cout << "Book not found." << std::endl;
    }

    return 0;
}

5. 常见问题与调试技巧

5.1 代码错误排查

常见的代码错误包括语法错误、逻辑错误和运行时错误。语法错误可以通过编译器提示找到，逻辑错误可以通过仔细检查代码逻辑，而运行时错误需要通过调试工具来定位。

5.2 常见编译错误及其解决方法

未定义的标识符：确保所有使用的标识符已经被正确声明。
类型不匹配：确保所有操作符和函数的参数类型一致。
缺少括号或分号：检查代码中的括号是否匹配，语句是否以分号结束。

5.3 调试工具简介

常用的调试工具包括 gdb、Visual Studio调试器和Xcode调试器。它们提供断点、单步执行、查看变量值等功能。

5.4 代码优化技巧

减少不必要的循环：合并循环，避免重复计算。
使用合适的数据结构：选择合适的数据结构可以显著提高性能。
避免使用全局变量：全局变量容易导致代码耦合，增加维护难度。
延迟加载和懒加载：只在需要时加载资源，可以减少内存消耗。

6. 项目总结与进阶学习

6.1 项目回顾

在图书管理系统项目中，我们学习了如何设计类图、实现类和对象，以及如何使用面向对象的设计原则来优化代码。通过这个项目，我们掌握了面向对象编程的基本概念和技能。

6.2 项目改进点

性能优化：可以考虑使用更高效的数据结构来提高搜索和排序的速度。
用户界面：可以添加图形界面或命令行界面来与用户交互。
异常处理：增加异常处理机制，提高系统的健壮性。

6.3 面向对象设计模式简介

面向对象设计模式是一些在面向对象系统设计中反复出现的问题的解决方案。常见的设计模式包括：

单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。
工厂模式（Factory Pattern）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
观察者模式（Observer Pattern）：定义对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

6.4 进一步学习资源推荐

慕课网：提供丰富的C++课程，从基础到高级，涵盖各种面向对象编程技巧和设计模式。
C++标准库文档：学习C++标准库提供的各种类和函数，以便更好地利用面向对象编程的优势。
在线编程社区：如Stack Overflow、C++ Reddit等，可以获取其他开发者的经验和建议。

通过不断学习和实践，你将能够更好地掌握面向对象编程的概念和技巧，并在实际项目中应用它们。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕莱坞森

手记
篇

粉丝

36

获赞与收藏

146

关注作者，订阅最新文章

阅读免费教程

设计模式入门教程

10个小节 22200 419

Android Studio 编辑器教程

40个小节 11963 247

后端通用面试教程

41个小节 31442 350

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空