如果你是算法工程师，请你使用QT编写一个算法基类(策略模式)。可以支持卡尔曼滤波算法和中位值滤波算法（包括具体输入）。每隔100ms或者300ms有温度、上腔压力、下腔压力实时数据输入，并且需要每隔1s取滤波后的结果

好的，以下是一个简单的算法基类实现，支持卡尔曼滤波算法和中位值滤波算法：

#include <QObject>
#include <QTimer>

class AlgorithmBase : public QObject
{
    Q_OBJECT
public:
    AlgorithmBase(QObject *parent = nullptr) : QObject(parent) {}
    virtual ~AlgorithmBase() {}

    virtual void setInput(double temp, double up, double down) = 0;
    virtual void getOutput(double &temp, double &up, double &down) = 0;
};

class KalmanFilter : public AlgorithmBase
{
public:
    KalmanFilter(QObject *parent = nullptr) : AlgorithmBase(parent) {}

    void setInput(double temp, double up, double down) override
    {
        // TODO: Kalman filter input implementation
    }

    void getOutput(double &temp, double &up, double &down) override
    {
        // TODO: Kalman filter output implementation
    }
};

class MedianFilter : public AlgorithmBase
{
public:
    MedianFilter(QObject *parent = nullptr) : AlgorithmBase(parent) {}

    void setInput(double temp, double up, double down) override
    {
        // TODO: Median filter input implementation
    }

    void getOutput(double &temp, double &up, double &down) override
    {
        // TODO: Median filter output implementation
    }
};

class FilterController : public QObject
{
    Q_OBJECT
public:
    FilterController(QObject *parent = nullptr) : QObject(parent)
    {
        m_algorithm = nullptr;
        m_inputTimer = new QTimer(this);
        m_inputTimer->setInterval(100);
        m_outputTimer = new QTimer(this);
        m_outputTimer->setInterval(1000);
        connect(m_inputTimer, &QTimer::timeout, this, &FilterController::onInputTimerTimeout);
        connect(m_outputTimer, &QTimer::timeout, this, &FilterController::onOutputTimerTimeout);
    }

    ~FilterController()
    {
        if (m_algorithm != nullptr) {
            delete m_algorithm;
        }
    }

    void setAlgorithm(AlgorithmBase *algorithm)
    {
        if (m_algorithm != nullptr) {
            delete m_algorithm;
        }
        m_algorithm = algorithm;
    }

    void start()
    {
        m_inputTimer->start();
        m_outputTimer->start();
    }

    void stop()
    {
        m_inputTimer->stop();
        m_outputTimer->stop();
    }

signals:
    void output(double temp, double up, double down);

private slots:
    void onInputTimerTimeout()
    {
        // TODO: Read real-time data and pass to algorithm input
        double temp = 0.0;
        double up = 0.0;
        double down = 0.0;
        if (m_algorithm != nullptr) {
            m_algorithm->setInput(temp, up, down);
        }
    }

    void onOutputTimerTimeout()
    {
        if (m_algorithm != nullptr) {
            double temp = 0.0;
            double up = 0.0;
            double down = 0.0;
            m_algorithm->getOutput(temp, up, down);
            emit output(temp, up, down);
        }
    }

private:
    AlgorithmBase *m_algorithm;
    QTimer *m_inputTimer;
    QTimer *m_outputTimer;
};

这个算法基类实现了一个虚拟的 `AlgorithmBase` 类，以及两个具体的类：卡尔曼滤波算法 `KalmanFilter` 和中位值滤波算法 `MedianFilter`。你可以在这两个类中实现具体的滤波逻辑。

`FilterController` 类则是控制器，它负责定时读取实时数据并传递给算法输入，同时定时读取算法输出并发出 `output` 信号。你可以根据需要修改定时器的间隔时间。

使用时，你需要先创建一个具体的算法对象（例如 `KalmanFilter` 或 `MedianFilter`），然后将其设置给 `FilterController` 对象，最后启动控制器即可：

KalmanFilter *kalmanFilter = new KalmanFilter();
FilterController *controller = new FilterController();
controller->setAlgorithm(kalmanFilter);
connect(controller, &FilterController::output, this, &MyClass::onOutput);
controller->start();

其中，`MyClass::onOutput` 是一个槽函数，用于处理滤波结果。你需要在该函数中对滤波后的数据进行进一步处理。