Java转C++之编程范式

1. 过程式编程（Procedural Programming）

在 C++ 中的表现

过程式编程是通过一系列的函数调用来实现程序的功能。函数是核心构建单元，数据和操作通过函数进行交互。

• C++ 中：可以使用普通的函数和全局变量来进行过程式编程。
• Java 中：虽然 Java 是面向对象的，但你可以通过 static 方法模拟过程式编程。

示例：

#include <iostream>
using namespace std;

void add(int a, int b) {
    cout << "Sum: " << a + b << endl;
}

int main() {
    int x = 10, y = 20;
    add(x, y);
    return 0;
}

在这个 C++ 示例中，add 函数像 Java 中的 static 方法一样，执行了某个操作，没有面向对象的封装。

2. 面向对象编程（Object-Oriented Programming, OOP）

在 C++ 中的表现

C++ 作为一种强大的面向对象编程语言，支持四大基本特性：封装、继承、多态、抽象。这与 Java 中的 OOP 范式非常相似，但 C++ 中可以直接访问底层内存，并且支持多重继承、指针等特性。

• C++ 中：

  • 支持类和对象
  • 支持构造函数、析构函数、虚函数
  • 支持多重继承
  • 支持指针和引用

• Java 中：Java 是纯粹的面向对象语言，每个类都是对象，但不支持多重继承（通过接口来解决）。

示例：

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数，接口
    virtual ~Shape() {}        // 虚析构函数，确保正确释放资源
};

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

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

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();
    
    shape1->draw();  // Drawing Circle
    shape2->draw();  // Drawing Square

    delete shape1;
    delete shape2;
    return 0;
}

在这个 C++ 示例中，Shape 是抽象类，Circle 和 Square 类从 Shape 派生，并实现 draw 方法。这与 Java 中的继承和多态非常相似，但 C++ 通过虚函数来实现动态绑定。

3. 泛型编程（Generic Programming）

在 C++ 中的表现

C++ 提供了强大的模板（template）机制，可以通过模板编写通用代码，这与 Java 中的泛型编程非常相似，但 C++ 中的模板支持更丰富的编译时计算和类型推导。

• C++ 中：模板支持函数模板和类模板，可以通过模板元编程进行复杂的编译时计算。
• Java 中：泛型主要用于提供类型安全，编译时会进行类型擦除，但无法像 C++ 一样进行编译时的类型计算。

示例：

#include <iostream>
using namespace std;

// 模板函数
template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    cout << add(10, 20) << endl;      // 输出 30
    cout << add(1.5, 2.5) << endl;    // 输出 4
    return 0;
}

在这个例子中，add 是一个模板函数，可以接受任意类型的参数，C++ 编译器会在编译时根据传入的类型生成相应的函数版本。Java 中的泛型也可以实现类似的功能，但 C++ 的模板更加灵活，能够在编译时进行更多的计算和类型推导。

4. 函数式编程（Functional Programming）

在 C++ 中的表现

C++ 支持函数式编程的一些特性，比如 Lambda 表达式 和 高阶函数，这使得你可以像 Java 中的函数式编程风格（例如使用 Stream API）一样，进行更简洁和声明式的编程。

• C++ 中：

  • Lambda 表达式可以创建匿名函数，允许你传递函数作为参数。
  • 高阶函数支持函数作为参数传递。
  • 支持 std::function 类型来封装可调用对象。

• Java 中：Java 8 引入了 lambda 表达式和 Stream API，也支持函数式编程。

示例：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

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

    // 使用 Lambda 表达式计算每个元素的平方
    for_each(v.begin(), v.end(), [](int x) { cout << x * x << " "; });

    cout << endl;
    return 0;
}

在这个 C++ 示例中，for_each 函数接受一个 Lambda 表达式作为参数，实现了类似 Java 中 Stream API 的操作。

5. 并发编程（Concurrent Programming）

在 C++ 中的表现

C++11 引入了对多线程的原生支持，提供了 std::thread 类，允许你在 C++ 中进行并发编程。

• C++ 中：

  • 使用 std::thread 来创建和管理线程。
  • 提供了 mutex 和 condition_variable 来处理同步。

• Java 中：Java 有更强的内建支持，使用 Thread 类和 Executor 框架进行并发编程。

示例：

#include <iostream>
#include <thread>
using namespace std;

void print_hello() {
    cout << "Hello from thread!" << endl;
}

int main() {
    thread t(print_hello);  // 启动一个新线程
    t.join();  // 等待线程结束
    return 0;
}

在这个 C++ 示例中，std::thread 用于创建一个新线程，并执行 print_hello 函数。

6. 元编程（Metaprogramming）

在 C++ 中的表现

C++ 支持 模板元编程（Template Metaprogramming, TMP），通过模板在编译时进行计算、类型推导等，极大地提升了程序的性能。Java 没有类似的元编程特性，主要依靠反射进行运行时的操作。

• C++ 中：模板元编程允许在编译时进行计算，并能根据类型特征选择不同的代码路径。
• Java 中：Java 使用反射 API，更多是在运行时进行类型信息获取和操作。

示例：

#include <iostream>
using namespace std;

template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static const int value = 1;
};

int main() {
    cout << Factorial<5>::value << endl;  // 输出 120
    return 0;
}

这个 C++ 示例通过模板在编译时计算出阶乘值，完全不依赖运行时的计算。

总结

作为一名 Java 专家，理解 C++ 的编程范式，你需要关注以下几点：

1. 过程式编程：通过函数组织代码，可以理解为 Java 中的 static 方法。
2. 面向对象编程（OOP）：C++ 强烈支持 OOP，特性与 Java 相似，但支持多重继承和指针，能更底层地操作内存。
3. 泛型编程：C++ 模板比 Java 泛型更加强大，支持编译时的类型推导和计算。
4. 函数式编程：C++ 通过 Lambda 表达式等实现函数式编程，类似 Java 中的 Stream API。
5. 并发编程：C++

11 引入了原生的多线程支持，Java 的 Thread 和 Executor 比较类似。
6. 元编程：C++ 强大的模板元编程能力是 Java 无法比拟的，允许编译时进行复杂计算。