在列立误差方程前先进行未知点的近似高程计算，在昨天给出的不用engin库的水准间接平差完整代码上进行修改

以下是在昨天给出的不使用Eigen库的水准间接平差完整代码基础上进行修改后的代码，添加了未知点的近似高程计算：

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

// 观测高差类的设计
class CElvDif {
private:
    double _value; // 观测值
    double _weight; // 权重
    long _startPoint; // 起始点编号
    long _endPoint; // 终点编号

public:
    // 构造函数
    CElvDif(double value, double weight, long startPoint, long endPoint)
        : _value(value), _weight(weight), _startPoint(startPoint), _endPoint(endPoint) {}

    // 获取观测值
    double getValue() const { return _value; }

    // 获取权重
    double getWeight() const { return _weight; }

    // 获取起始点编号
    long getStartPoint() const { return _startPoint; }

    // 获取终点编号
    long getEndPoint() const { return _endPoint; }
};

// 水准点类的设计
class CLevelPoint {
private:
    long _index; // 水准点编号
    double _eleValue; // 高程值
    double _dv; // 高程值改正数（初始化为 0）
    bool _isKnown; // 是否为已知点

public:
    // 构造函数
    CLevelPoint(long index, double eleValue, bool isKnown)
        : _index(index), _eleValue(eleValue), _dv(0.0), _isKnown(isKnown) {}

    // 获取水准点编号
    long getIndex() const { return _index; }

    // 获取高程值
    double getEleValue() const { return _eleValue; }

    // 设置高程值
    void setEleValue(double value) { _eleValue = value; }

    // 获取高程值改正数
    double getDv() const { return _dv; }

    // 设置高程值改正数
    void setDv(double value) { _dv = value; }

    // 是否为已知点
    bool isKnown() const { return _isKnown; }
};

// 水准平差计算类的设计
class CElevationNet {
private:
    int numElvDif; // 观测值（高差）总数
    int numPoints; // 控制网中点的数目
    int numKnPoint; // 控制网中已知点的数目
    double sigma0; // 验前单位权中误差
    std::vector<CElvDif> _edVec; // 观测值数组
    std::vector<CLevelPoint> _lpVec; // 高程值数组

public:
    // 构造函数
    CElevationNet() : numElvDif(0), numPoints(0), numKnPoint(0), sigma0(0.0) {}

    // 读取数据文件
    bool readDataFile(const std::string& filename) {
        std::ifstream file(filename);
        if (!file.is_open()) {
            std::cout << "Failed to open file: " << filename << std::endl;
            return false;
        }

        file >> numPoints >> numKnPoint >> numElvDif >> sigma0;

        // 读取已知点的信息
        for (int i = 0; i < numKnPoint; i++) {
            long index;
            double eleValue;
            file >> index >> eleValue;
            _lpVec.push_back(CLevelPoint(index, eleValue, true));
        }

        // 读取未知点的信息
        for (int i = 0; i < numPoints - numKnPoint; i++) {
            long index;
            double eleValue;
            file >> index >> eleValue;
            _lpVec.push_back(CLevelPoint(index, eleValue, false));
        }

        // 读取观测高差的信息
        for (int i = 0; i < numElvDif; i++) {
            double value, weight;
            long startPoint, endPoint;
            file >> value >> weight >> startPoint >> endPoint;
            _edVec.push_back(CElvDif(value, weight, startPoint, endPoint));
        }

        file.close();
        return true;
    }

    // 计算未知点的近似高程
    void computeApproximateElevation() {
        // 计算未知点的近似高程
        std::vector<double> approxEle(numPoints - numKnPoint, 0.0);

        for (int i = numKnPoint; i < numPoints; i++) {
            double sum = 0.0;
            int count = 0;

            for (const auto& elvDif : _edVec) {
                long startPoint = elvDif.getStartPoint();
                long endPoint = elvDif.getEndPoint();
                double value = elvDif.getValue();

                if ((startPoint == i + 1 && _lpVec[endPoint - 1].isKnown()) ||
                    (endPoint == i + 1 && _lpVec[startPoint - 1].isKnown())) {
                    sum += value;
                    count++;
                }
            }

            if (count > 0) {
                approxEle[i - numKnPoint] = sum / count;
            }
        }

        // 更新未知点的高程值
        for (int i = numKnPoint; i < numPoints; i++) {
            _lpVec[i].setEleValue(approxEle[i - numKnPoint]);
        }
    }

    // 水准平差计算
    void elevationAdjustment() {
        // 构建法方程系数矩阵A和常数项b
        std::vector<std::vector<double>> A(numElvDif + numKnPoint, std::vector<double>(numPoints - numKnPoint, 0.0));
        std::vector<double> b(numElvDif + numKnPoint, 0.0);

        // 构建误差方程
        int row = 0;
        for (const auto& elvDif : _edVec) {
            long startPoint = elvDif.getStartPoint();
            long endPoint = elvDif.getEndPoint();
            double weight = elvDif.getWeight();
            double value = elvDif.getValue();

            if (_lpVec[startPoint - 1].isKnown() && _lpVec[endPoint - 1].isKnown()) {
                // 已知-已知高差观测
                double eleStart = _lpVec[startPoint - 1].getEleValue();
                double eleEnd = _lpVec[endPoint - 1].getEleValue();
                double residual = eleStart - eleEnd + value;
                b[row] = residual * weight;
            } else {
                // 未知-已知高差观测
                if (_lpVec[startPoint - 1].isKnown()) {
                    // 起点为已知点
                    A[row][startPoint - numKnPoint - 1] = 1.0;
                    b[row] = _lpVec[startPoint - 1].getEleValue() + value;
                } else if (_lpVec[endPoint - 1].isKnown()) {
                    // 终点为已知点
                    A[row][endPoint - numKnPoint - 1] = -1.0;
                    b[row] = _lpVec[endPoint - 1].getEleValue() - value;
                }
            }

            row++;
        }

        // 构建法方程和常数项
        for (int i = 0; i < numKnPoint; i++) {
            A[row][i] = 1.0;
            b[row] = _lpVec[i].getEleValue();
            row++;
        }

        // 解算法方程
        std::vector<double> x(numPoints - numKnPoint, 0.0);
        gaussElimination(A, b, x);

        // 更新未知点的高程值
        for (int i = numKnPoint; i < numPoints; i++) {
            _lpVec[i].setEleValue(x[i - numKnPoint]);
        }
    }

    // 高斯消元法解方程
    void gaussElimination(const std::vector<std::vector<double>>& A, const std::vector<double>& b, std::vector<double>& x) {
        int n = A.size();
        std::vector<std::vector<double>> augmentedMatrix(n, std::vector<double>(n + 1, 0.0));

        // 构建增广矩阵
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                augmentedMatrix[i][j] = A[i][j];
            }
            augmentedMatrix[i][n] = b[i];
        }

        // 高斯消元法求解
        for (int i = 0; i < n - 1; i++) {
            // 首元素非零处理
            if (augmentedMatrix[i][i] == 0) {
                int j = i + 1;
                while (j < n && augmentedMatrix[j][i] == 0) {
                    j++;
                }
                if (j == n) {
                    std::cout << "Error: Singular matrix!" << std::endl;
                    return;
                }
                std::swap(augmentedMatrix[i], augmentedMatrix[j]);
            }

            for (int j = i + 1; j < n; j++) {
                double factor = augmentedMatrix[j][i] / augmentedMatrix[i][i];
                for (int k = i; k <= n; k++) {
                    augmentedMatrix[j][k] -= factor * augmentedMatrix[i][k];
                }
            }
        }

        // 回代求解
        for (int i = n - 1; i >= 0; i--) {
            x[i] = augmentedMatrix[i][n] / augmentedMatrix[i][i];
            for (int j = i - 1; j >= 0; j--) {
                augmentedMatrix[j][n] -= augmentedMatrix[j][i] * x[i];
            }
        }
    }

    // 输出结果
    void printResults() const {
        std::cout << "Elevation Adjustment Results:" << std::endl;

        // 输出已知点的高程值
        std::cout << "Known Points: " << std::endl;
        for (const auto& point : _lpVec) {
            if (point.isKnown()) {
                std::cout << "Point " << point.getIndex() << ": " << point.getEleValue() << std::endl;
            }
        }

        // 输出未知点的高程值
        std::cout << "Unknown Points: " << std::endl;
        for (const auto& point : _lpVec) {
            if (!point.isKnown()) {
                std::cout << "Point " << point.getIndex() << ": " << point.getEleValue() << std::endl;
            }
        }

        // 计算未知点高程值的精度估计
        double sigma_a = sqrt(sigma0 * sigma0 / (numElvDif - numPoints + numKnPoint));
        std::cout << "Standard Deviation: " << sigma_a << std::endl;
    }
};

int main() {
    CElevationNet elevationNet;

    // 读取数据文件
    if (!elevationNet.readDataFile("data.txt")) {
        return 0;
    }

    // 计算未知点的近似高程
    elevationNet.computeApproximateElevation();

    // 进行水准平差计算
    elevationNet.elevationAdjustment();

    // 输出结果
    elevationNet.printResults();

    return 0;
}

请将上述代码保存为一个名为 `elevation_adjustment.cpp` 的文件，并将数据文件命名为 `data.txt` 并放在同一目录下。然后编译并运行该程序，即可得到水准间接平差的结果。