用C＋＋实现G(s)=1/(s^2*（0.1*s+1）)的P、PD、PI、PID、积分器饱和PID、不完全微分PID、微分先行PID控制，并分析各控制器的控制效果。

好的，我会尽力回答您的问题。

首先，我们需要了解G(s)的特性和控制器的基本原理。

G(s)是一个二阶惯性系统，分母有一个一阶项和一个二阶项，表明了系统存在一定的惯性和阻尼特性。在控制器设计中，我们常使用传递函数的形式进行分析和设计。

P控制器是比较简单的控制器，只有比例项，可以增大稳态误差的比例，但是对于系统的动态响应影响较小，一般不用于二阶系统的控制。

PD控制器在P控制器的基础上增加了一个微分项，可以使系统更快地响应，减小超调量，但是会使系统的稳定性变差。

PI控制器在P控制器的基础上增加了一个积分项，可以消除稳态误差，但是会使系统的超调量增大，响应变慢。

PID控制器是综合了P、I、D三个控制器的优点，可以同时消除稳态误差、减小超调量、加快系统响应。

积分器饱和PID控制器在PID控制器的基础上增加了积分器饱和保护，可以避免积分器饱和时系统不稳定的情况。

不完全微分PID控制器在PID控制器的基础上增加了不完全微分项，可以减小系统的超调量和振荡，但是会使系统的响应变慢。

微分先行PID控制器在PID控制器的基础上增加了微分先行项，可以在系统受到干扰时提前响应，减小干扰对系统的影响，但是会使系统的稳定性变差。

接下来，我们可以使用C++语言编写这些控制器并进行仿真，从而对比分析它们的控制效果。由于篇幅限制，我只提供代码框架供参考。

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

// 传递函数G(s)
class G {
public:
    double operator()(double s) {
        return 1.0 / (s * s * (0.1 * s + 1));
    }
};

// P控制器
class P {
public:
    double operator()(double e) {
        return kp * e;
    }
    double kp;
};

// PD控制器
class PD {
public:
    double operator()(double e, double de) {
        return kp * e + kd * de;
    }
    double kp, kd;
};

// PI控制器
class PI {
public:
    double operator()(double e, double ie) {
        return kp * e + ki * ie;
    }
    double kp, ki;
};

// PID控制器
class PID {
public:
    double operator()(double e, double de, double ie) {
        return kp * e + kd * de + ki * ie;
    }
    double kp, kd, ki;
};

// 积分器饱和PID控制器
class SaturatePID {
public:
    double operator()(double e, double de, double ie) {
        ie = max(min(ie, isat), -isat);
        return kp * e + kd * de + ki * ie;
    }
    double kp, kd, ki, isat;
};

// 不完全微分PID控制器
class IncompleteDifferentialPID {
public:
    double operator()(double e, double de, double ide) {
        double dde = a * de + (1 - a) * ide;
        return kp * e + kd * dde + ki * ide;
    }
    double kp, kd, ki, a;
};

// 微分先行PID控制器
class DifferentialLeadPID {
public:
    double operator()(double e, double de, double ide, double dde) {
        return kp * e + kd * dde + ki * ide;
    }
    double kp, kd, ki;
};

int main() {
    double ts = 0.01; // 采样时间
    double t = 0.0; // 当前时间
    double te = 10.0; // 结束时间
    double e, de, ie, dde; // 误差、误差变化率、误差积分、误差变化率变化率
    double y = 0.0, yp = 0.0; // 输出、上一次输出
    double dt = 0.0; // 采样间隔
    int n = 0; // 采样计数器

    G g;
    P p;
    PD pd;
    PI pi;
    PID pid;
    SaturatePID spid;
    IncompleteDifferentialPID idpid;
    DifferentialLeadPID dlpid;

    // 控制器参数
    p.kp = 1.0;
    pd.kp = 1.0;
    pd.kd = 1.0;
    pi.kp = 1.0;
    pi.ki = 1.0;
    pid.kp = 1.0;
    pid.kd = 1.0;
    pid.ki = 1.0;
    spid.kp = 1.0;
    spid.kd = 1.0;
    spid.ki = 1.0;
    spid.isat = 1.0;
    idpid.kp = 1.0;
    idpid.kd = 1.0;
    idpid.ki = 1.0;
    idpid.a = 0.9;
    dlpid.kp = 1.0;
    dlpid.kd = 1.0;
    dlpid.ki = 1.0;

    while (t <= te) {
        // 计算误差和误差变化率
        e = 1 - g(t);
        de = (y - yp) / dt;

        // 计算误差积分、误差变化率变化率
        ie += e * dt;
        dde = (de - dep) / dt;

        // 计算控制器输出
        double u_p = p(e);
        double u_pd = pd(e, de);
        double u_pi = pi(e, ie);
        double u_pid = pid(e, de, ie);
        double u_spid = spid(e, de, ie);
        double u_idpid = idpid(e, de, ide);
        double u_dlpid = dlpid(e, de, ide, dde);

        // 计算输出
        yp = y;
        y = g(t + dt);

        // 更新时间和采样计数器
        t += dt;
        n += 1;
    }

    return 0;
}

以上是C++语言的代码框架，您可以根据自己的需求进行修改和完善。需要注意的是，对于二阶系统的控制，我们可能需要对控制器进行进一步优化和调试，以达到最佳的控制效果。