C++篇启航——初识C++（下篇）

引言

在前篇中，我们已经初步了解了C++的基本概念、语法以及一些简单的应用场景。在本篇文章中，我们将深入探讨C++的更多特性，并通过案例分析来展示其在实际开发中的应用。我们会涵盖面向对象编程、标准模板库（STL）、异常处理等重要主题，并通过实例来帮助大家更好地理解这些概念。

1. 面向对象编程

1.1 什么是面向对象编程？

面向对象编程（OOP）是一种编程范式，通过“对象”来组织代码。对象是类的实例，类则是对一组对象的抽象。OOP的四大特性包括封装、继承、多态和抽象。

1.2 封装

封装是指将数据和操作数据的方法结合在一起，限制外部对数据的直接访问。这种方法可以提高代码的安全性和可维护性。

示例：封装的使用

cppCopy Code
#include <iostream>
#include <string>

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

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

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            std::cout << "Deposited: " << amount << ", New balance: " << balance << std::endl;
        }
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            std::cout << "Withdrew: " << amount << ", New balance: " << balance << std::endl;
        } else {
            std::cout << "Withdrawal failed. Insufficient funds." << std::endl;
        }
    }

    void displayBalance() const {
        std::cout << "Account Number: " << accountNumber << ", Balance: " << balance << std::endl;
    }
};

int main() {
    BankAccount account("123456789", 1000.0);
    account.deposit(500);
    account.withdraw(200);
    account.displayBalance();

    return 0;
}

1.3 继承

继承允许我们创建一个新类（子类），该类从现有类（父类）继承属性和方法。这促进了代码重用。

示例：继承的使用

cppCopy Code
#include <iostream>
#include <string>

class Animal {
public:
    void speak() {
        std::cout << "Animal speaks!" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        std::cout << "Dog barks!" << std::endl;
    }
};

int main() {
    Animal animal;
    Dog dog;

    animal.speak(); // 输出：Animal speaks!
    dog.speak(); // 输出：Dog barks!

    return 0;
}

1.4 多态

多态是指同一操作作用于不同对象时，可以表现出不同的行为。C++通过函数重载和虚函数实现多态。

示例：多态的使用

cppCopy Code
#include <iostream>

class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape." << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a square." << std::endl;
    }
};

void drawShape(Shape* shape) {
    shape->draw();
}

int main() {
    Circle circle;
    Square square;

    drawShape(&circle); // 输出：Drawing a circle.
    drawShape(&square); // 输出：Drawing a square.

    return 0;
}

1.5 抽象

抽象是指通过定义抽象类，只有通过派生类实现具体功能。抽象类包含至少一个纯虚函数。

示例：抽象类的使用

cppCopy Code
#include <iostream>

class AbstractShape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Rectangle : public AbstractShape {
public:
    void draw() override {
        std::cout << "Drawing a rectangle." << std::endl;
    }
};

int main() {
    Rectangle rectangle;
    rectangle.draw(); // 输出：Drawing a rectangle.

    return 0;
}

2. 标准模板库（STL）

C++标准模板库（STL）是一个功能强大的工具集，提供了许多可重用的组件，如容器、算法和迭代器。

2.1 容器

STL容器是一种用于存储对象的类，包括序列容器和关联容器。

示例：使用向量（vector）

cppCopy Code
#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;

    // 添加元素
    numbers.push_back(10);
    numbers.push_back(20);
    numbers.push_back(30);

    // 访问元素
    for (size_t i = 0; i < numbers.size(); ++i) {
        std::cout << "Element at index " << i << ": " << numbers[i] << std::endl;
    }

    return 0;
}

2.2 算法

STL还提供了多种算法，例如排序、查找和修改容器中的元素。

示例：使用算法排序

cppCopy Code
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {4, 1, 3, 9, 2};

    // 排序
    std::sort(numbers.begin(), numbers.end());

    // 输出排序后的数组
    std::cout << "Sorted numbers: ";
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

2.3 迭代器

迭代器是一种用于遍历容器元素的对象。STL提供了多种类型的迭代器，如输入迭代器、输出迭代器和双向迭代器。

示例：使用迭代器遍历容器

cppCopy Code
#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用迭代器遍历
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

3. 异常处理

在C++中，异常处理是一种机制，用于处理程序运行时发生的错误或异常情况。

3.1 异常的基本概念

C++使用try、catch和throw来进行异常处理。

示例：基础异常处理

cppCopy Code
#include <iostream>
#include <stdexcept>

void divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("Division by zero!");
    }
    std::cout << "Result: " << a / b << std::endl;
}

int main() {
    try {
        divide(10, 2); // 正常情况
        divide(10, 0); // 将抛出异常
    } catch (const std::invalid_argument& e) {
        std::cerr << "Caught an exception: " << e.what() << std::endl;
    }

    return 0;
}

4. 文件操作

C++标准库还提供了文件输入输出（I/O）功能，以便于对文件的读写操作。

4.1 文件写入

cppCopy Code
#include <iostream>
#include <fstream>

int main() {
    std::ofstream outFile("output.txt");
    if (outFile.is_open()) {
        outFile << "Hello, file!" << std::endl;
        outFile.close();
    } else {
        std::cerr << "Unable to open file for writing." << std::endl;
    }

    return 0;
}

4.2 文件读取

cppCopy Code
#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ifstream inFile("output.txt");
    std::string line;

    if (inFile.is_open()) {
        while (getline(inFile, line)) {
            std::cout << line << std::endl;
        }
        inFile.close();
    } else {
        std::cerr << "Unable to open file for reading." << std::endl;
    }

    return 0;
}

5. C++11及后续特性

C++11引入了许多新特性，使得编码更加简洁和高效。

5.1 自动类型推导（auto）

C++11支持使用auto关键字来自动推导变量类型。

示例：使用auto

cppCopy Code
#include <iostream>
#include <vector>

int main() {
    auto x = 10; // 整数类型
    auto y = 3.14; // 浮点类型
    auto numbers = std::vector<int>{1, 2, 3, 4, 5};

    for (auto num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

5.2 范围for循环

C++11引入了范围for循环，使得遍历容器更加方便。

示例：范围for循环

cppCopy Code
#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    for (const auto& val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

5.3 智能指针

智能指针是C++11中引入的，用于管理动态分配的内存，减少内存泄漏的风险。

示例：使用std::shared_ptr

cppCopy Code
#include <iostream>
#include <memory>

class Sample {
public:
    Sample() { std::cout << "Sample created." << std::endl; }
    ~Sample() { std::cout << "Sample destroyed." << std::endl; }
};

int main() {
    std::shared_ptr<Sample> ptr1 = std::make_shared<Sample>();
    {
        std::shared_ptr<Sample> ptr2 = ptr1; // 引用计数增加
        std::cout << "Inside block." << std::endl;
    } // ptr2超出作用域，引用计数减少
    std::cout << "Outside block." << std::endl;

    return 0;
}

结论

在本篇中，我们深入探讨了C++的面向对象编程、标准模板库、异常处理、文件操作以及C++11及以后版本的新特性。通过示例代码，我们看到了C++在实际应用中的强大功能和灵活性。希望大家能够结合这些知识，进一步提高自己的编程能力，开启更广阔的C++编程之旅。

参考文献

Bjarne Stroustrup, "The C++ Programming Language"
Nicolai M. Josuttis, "The C++ Standard Library: A Tutorial and Reference"
C++标准文档

以上内容只是一个大纲和示例部分。如果要撰写完整的5000字文章，需要在每个部分添加更多细节、示例和解释。同时，可以通过不同的项目和应用场景来进一步扩展内容。

C++篇 启航——初识C++（下篇）

引言