c++函数传入std::vector<double>参数 写一个完整的例子

下面是一个简单的例子，演示如何在C++函数中使用`std::vector<double>`参数：

#include <iostream>
#include <vector>

// 使用 std::vector<double> 参数的函数
void print_vector(std::vector<double> vec) {
    for (double d : vec) {
        std::cout << d << " ";
    }
    std::cout << std::endl;
}

int main() {
    // 初始化一个 double 类型的 vector
    std::vector<double> my_vector = { 1.0, 2.0, 3.0, 4.0, 5.0 };

    // 调用函数并传入 vector 参数
    print_vector(my_vector);

    return 0;
}

在上面的示例中，我们定义了一个名为`print_vector`的函数，它使用`std::vector<double>`参数打印向量中的每个元素。在`main`函数中，我们初始化一个`std::vector<double>`并将其传递给`print_vector`函数。

需要注意的是，当您将`std::vector`作为参数传递给函数时，实际上是将指向向量数据的指针传递给函数。因此，如果您在函数中修改向量的元素，这些更改将在函数调用返回后保留。

相关问题

c++函数传入std::vector<double>参数

如果你需要在C++函数中传入一个std::vector<double>参数，你可以使用以下语法：

void myFunction(const std::vector<double>& myVector) {
    // 在函数中使用myVector
}

这里使用了引用传递，这意味着函数将接受到的参数作为引用而不是副本进行操作，这使得函数可以直接修改传入的向量而不需要进行复制。`const`关键字表示函数不会修改传入的向量。在函数中使用`myVector`就像使用一个常规的向量一样。你可以使用`myVector.size()`来获取向量大小，使用`myVector[index]`来访问向量中的元素，等等。

多元多项式回归 C++带类详细完整实现及案例 变量形式为：vector<vector<double>> X vector<double> y

好的，下面是多元多项式回归的 C++ 实现，包括类的定义、成员函数的实现和示例代码：

#include <iostream>
#include <vector>

using namespace std;

// 多元多项式回归类
class PolynomialRegression {
private:
    int degree; // 多项式次数
    vector<vector<double>> X; // 自变量矩阵
    vector<double> y; // 因变量向量
    vector<double> coefficients; // 多项式系数向量

public:
    // 构造函数
    PolynomialRegression(int d, vector<vector<double>> x, vector<double> y) {
        degree = d;
        X = x;
        this->y = y;
        fit();
    }

    // 多项式回归模型拟合
    void fit() {
        int n = X.size();
        int m = X[0].size();

        // 计算 X 矩阵的转置
        vector<vector<double>> X_T(m, vector<double>(n));
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                X_T[i][j] = X[j][i];
            }
        }

        // 计算 X_T * X 矩阵
        vector<vector<double>> X_T_X(m, vector<double>(m));
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                for (int k = 0; k < n; k++) {
                    X_T_X[i][j] += X_T[i][k] * X[k][j];
                }
            }
        }

        // 计算 X_T * y 向量
        vector<double> X_T_y(m);
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                X_T_y[i] += X_T[i][j] * y[j];
            }
        }

        // 求解线性方程组 X_T * X * coefficients = X_T * y
        for (int k = 0; k < degree + 1; k++) {
            for (int i = k; i < m; i++) {
                double factor = X_T_X[i][k] / X_T_X[k][k];
                for (int j = k; j < m; j++) {
                    X_T_X[i][j] -= factor * X_T_X[k][j];
                }
                X_T_y[i] -= factor * X_T_y[k];
            }
        }

        // 回代求解系数向量
        coefficients.resize(degree + 1);
        for (int k = degree; k >= 0; k--) {
            double s = 0;
            for (int i = k + 1; i < degree + 1; i++) {
                s += X_T_X[k][i] * coefficients[i];
            }
            coefficients[k] = (X_T_y[k] - s) / X_T_X[k][k];
        }
    }

    // 预测函数
    double predict(vector<double> x) {
        double y_pred = 0;
        for (int i = 0; i < degree + 1; i++) {
            double term = coefficients[i];
            for (int j = 0; j < x.size(); j++) {
                term *= pow(x[j], i);
            }
            y_pred += term;
        }
        return y_pred;
    }

    // 打印多项式系数向量
    void print_coefficients() {
        cout << "Polynomial coefficients:" << endl;
        for (int i = 0; i < degree + 1; i++) {
            cout << coefficients[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    // 构造数据集
    vector<vector<double>> X = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
    vector<double> y = {1, 2, 3, 4};

    // 构造多项式回归模型
    PolynomialRegression pr(2, X, y);

    // 输出多项式系数向量
    pr.print_coefficients();

    // 预测新的样本
    vector<double> x_pred = {1, 2, 3};
    double y_pred = pr.predict(x_pred);
    cout << "Predicted value: " << y_pred << endl;

    return 0;
}

在上面的代码中，我们定义了一个多元多项式回归类 `PolynomialRegression`，包含 `degree`、`X`、`y` 和 `coefficients` 四个成员变量，以及 `fit()`、`predict()` 和 `print_coefficients()` 三个成员函数。

在构造函数中，我们传入多项式的次数 `degree`、自变量矩阵 `X` 和因变量向量 `y`，并调用 `fit()` 函数进行模型拟合。在 `fit()` 函数中，我们使用最小二乘法求解多项式系数向量 `coefficients`，并存储到类的成员变量中。

在 `predict()` 函数中，我们输入一个自变量向量 `x`，使用多项式系数向量 `coefficients` 进行预测，并返回预测值。在 `print_coefficients()` 函数中，我们打印多项式系数向量 `coefficients` 的值。

在主函数中，我们构造一个数据集 `X` 和 `y`，并使用 `PolynomialRegression` 类构造一个多项式回归模型 `pr`。然后，我们输出多项式系数向量，以及使用 `predict()` 函数预测新的样本的结果。

希望这个实现对你有帮助！