当前位置：首页 > news >正文

弹簧质点系统（C++实现）

news 来源：原创 2025/5/11 1:20:17

本文实现一个简单的物理算法：弹簧质点系统（Mass-Spring System）。这是一个经典的物理模拟算法，常用于模拟弹性物体（如布料、弹簧等）的行为。我们将使用C++来实现这个算法，并结合链表数据结构来管理质点和弹簧。

1. 问题描述

弹簧质点系统由多个质点和连接它们的弹簧组成。每个质点受到重力和弹簧力的作用，我们可以通过牛顿第二定律计算质点的加速度，进而更新其速度和位置。

2. 数据结构设计

质点（Mass）：包含质量、位置、速度、加速度等属性。
弹簧（Spring）：连接两个质点，包含弹簧常数、自然长度等属性。
系统（System）：管理所有质点和弹簧，使用链表存储。

3. 算法实现

#include <iostream>
#include <vector>
#include <cmath>

// 定义二维向量
struct Vector2 {
    double x, y;
    Vector2(double x = 0, double y = 0) : x(x), y(y) {}
    Vector2 operator+(const Vector2& other) const {
        return Vector2(x + other.x, y + other.y);
    }
    Vector2 operator-(const Vector2& other) const {
        return Vector2(x - other.x, y - other.y);
    }
    Vector2 operator*(double scalar) const {
        return Vector2(x * scalar, y * scalar);
    }
    double length() const {
        return std::sqrt(x * x + y * y);
    }
};

// 质点类
struct Mass {
    double mass;       // 质量
    Vector2 position;  // 位置
    Vector2 velocity;  // 速度
    Vector2 force;     // 受力

    Mass(double m, Vector2 pos) : mass(m), position(pos), velocity(0, 0), force(0, 0) {}

    void applyForce(Vector2 f) {
        force = force + f;
    }

    void update(double dt) {
        Vector2 acceleration = force * (1.0 / mass);  // 牛顿第二定律
        velocity = velocity + acceleration * dt;      // 更新速度
        position = position + velocity * dt;         // 更新位置
        force = Vector2(0, 0);                        // 重置受力
    }
};

// 弹簧类
struct Spring {
    Mass* mass1;  // 连接的质点1
    Mass* mass2;  // 连接的质点2
    double k;     // 弹簧常数
    double restLength;  // 自然长度

    Spring(Mass* m1, Mass* m2, double k, double restLen)
        : mass1(m1), mass2(m2), k(k), restLength(restLen) {}

    void applyForce() {
        Vector2 delta = mass2->position - mass1->position;
        double length = delta.length();
        double forceMagnitude = k * (length - restLength);  // 胡克定律
        Vector2 force = delta * (forceMagnitude / length);
        mass1->applyForce(force);
        mass2->applyForce(force * -1);
    }
};

// 系统类
struct System {
    std::vector<Mass*> masses;    // 质点链表
    std::vector<Spring*> springs; // 弹簧链表

    void addMass(Mass* mass) {
        masses.push_back(mass);
    }

    void addSpring(Spring* spring) {
        springs.push_back(spring);
    }

    void update(double dt) {
        // 应用重力
        for (auto mass : masses) {
            mass->applyForce(Vector2(0, -9.8 * mass->mass));  // 重力
        }

        // 应用弹簧力
        for (auto spring : springs) {
            spring->applyForce();
        }

        // 更新质点状态
        for (auto mass : masses) {
            mass->update(dt);
        }
    }
};

int main() {
    // 创建系统
    System system;

    // 创建质点
    Mass* mass1 = new Mass(1.0, Vector2(0, 0));
    Mass* mass2 = new Mass(1.0, Vector2(2, 0));
    system.addMass(mass1);
    system.addMass(mass2);

    // 创建弹簧
    Spring* spring = new Spring(mass1, mass2, 10.0, 1.0);
    system.addSpring(spring);

    // 模拟
    double dt = 0.01;  // 时间步长
    for (int i = 0; i < 100; i++) {
        system.update(dt);
        std::cout << "Mass1 Position: (" << mass1->position.x << ", " << mass1->position.y << ")\n";
        std::cout << "Mass2 Position: (" << mass2->position.x << ", " << mass2->position.y << ")\n";
    }

    // 释放内存
    delete mass1;
    delete mass2;
    delete spring;

    return 0;
}