用C/C++实现下列对象的P、PD、PI、PID、积分器饱和PID、不完全微分PID、微分先行PID控制G(s)=1/(s^2.*(0.1*s+1));

以下是用C++实现对象的P、PD、PI、PID、积分器饱和PID、不完全微分PID、微分先行PID控制G(s)=1/(s^2.*(0.1*s+1))的代码：

#include <iostream>
#include <cmath>

using namespace std;

class Controller {
public:
    virtual double calculate(double e) = 0;
    virtual void reset() = 0;
};

class PController : public Controller {
public:
    PController(double kp) : _kp(kp) {}
    double calculate(double e) override {
        return _kp * e;
    }
    void reset() override {}
private:
    double _kp;
};

class PDController : public Controller {
public:
    PDController(double kp, double kd) : _kp(kp), _kd(kd), _last_e(0) {}
    double calculate(double e) override {
        double de = e - _last_e;
        _last_e = e;
        return _kp * e + _kd * de;
    }
    void reset() override {
        _last_e = 0;
    }
private:
    double _kp, _kd, _last_e;
};

class PIController : public Controller {
public:
    PIController(double kp, double ki, double i_max) : _kp(kp), _ki(ki), _i_max(i_max) {}
    double calculate(double e) override {
        _i += e;
        if (_i > _i_max) {
            _i = _i_max;
        } else if (_i < -_i_max) {
            _i = -_i_max;
        }
        return _kp * e + _ki * _i;
    }
    void reset() override {
        _i = 0;
    }
private:
    double _kp, _ki, _i_max, _i = 0;
};

class PIDController : public Controller {
public:
    PIDController(double kp, double ki, double kd, double i_max) : _kp(kp), _ki(ki), _kd(kd), _i_max(i_max) {}
    double calculate(double e) override {
        double de = e - _last_e;
        _last_e = e;
        _i += e;
        if (_i > _i_max) {
            _i = _i_max;
        } else if (_i < -_i_max) {
            _i = -_i_max;
        }
        return _kp * e + _ki * _i + _kd * de;
    }
    void reset() override {
        _last_e = 0;
        _i = 0;
    }
private:
    double _kp, _ki, _kd, _i_max, _last_e = 0, _i = 0;
};

class SaturationController : public Controller {
public:
    SaturationController(Controller* controller, double min_output, double max_output) : _controller(controller), _min_output(min_output), _max_output(max_output) {}
    double calculate(double e) override {
        double output = _controller->calculate(e);
        if (output > _max_output) {
            output = _max_output;
        } else if (output < _min_output) {
            output = _min_output;
        }
        return output;
    }
    void reset() override {
        _controller->reset();
    }
private:
    Controller* _controller;
    double _min_output, _max_output;
};

class IncompleteDerivativeController : public Controller {
public:
    IncompleteDerivativeController(double kp, double kd, double tau) : _kp(kp), _kd(kd), _tau(tau), _last_e(0) {}
    double calculate(double e) override {
        double de = (e - _last_e) / _tau;
        _last_e = e;
        return _kp * e + _kd * de;
    }
    void reset() override {
        _last_e = 0;
    }
private:
    double _kp, _kd, _tau, _last_e;
};

class DerivativeFeedforwardController : public Controller {
public:
    DerivativeFeedforwardController(double kp, double kd, double tau, double g) : _kp(kp), _kd(kd), _tau(tau), _g(g), _last_e(0) {}
    double calculate(double e) override {
        double de = (e - _last_e) / _tau;
        _last_e = e;
        return _kp * e + _kd * de + _g;
    }
    void reset() override {
        _last_e = 0;
    }
private:
    double _kp, _kd, _tau, _g, _last_e;
};

int main() {
    double s = 0.1;
    double tau = 1 / s;
    double kp = 1, ki = 0.1, kd = 0.1, i_max = 10, g = 1 / pow(s, 2) / (s + tau);
    Controller* controller = new PIDController(kp, ki, kd, i_max);
    controller = new SaturationController(controller, -10, 10);
    controller = new IncompleteDerivativeController(kp, kd, tau);
    controller = new DerivativeFeedforwardController(kp, kd, tau, g);
    // 使用控制器进行控制
    controller->calculate(1);
    // 重置控制器
    controller->reset();
    // 释放控制器
    delete controller;
    return 0;
}

其中，`Controller` 是控制器的基类，包含了 `calculate` 计算控制量和 `reset` 重置控制器状态的虚函数。`PController`、`PDController`、`PIController`、`PIDController` 是分别实现了 P、PD、PI、PID 控制的类，`SaturationController` 是饱和控制器，用于限制控制量在一定范围内，`IncompleteDerivativeController` 是不完全微分控制器，`DerivativeFeedforwardController` 是微分先行控制器，这两个控制器都是对 PID 控制的改进。在 `main` 函数中，我们可以根据需要组合不同的控制器来实现对 G(s)=1/(s^2.*(0.1*s+1)) 的控制。