1、c++语言设计并实现一个支持一元非线性方程求根的类，至少支持二分法和牛顿迭代法，具有通用性。 2、利用内容1的结果，求出一元非线性方程f(x)=x^3-sinx-4x+1的全部实根，其中精度。

在C++中，我们可以设计一个名为`NonlinearEquationSolver`的类，它包含两种解一元非线性方程的算法：二分法（Bisection Method）和牛顿迭代法（Newton's Method）。这个类将接受用户自定义的函数f(x)，并提供一个公共方法来计算方程的根，同时允许设置精度。

#include <cmath>
#include <vector>

class NonlinearEquationSolver {
private:
    double (*function)(double);
    double left, right;
    double tolerance;
    int max_iterations;

public:
    // 构造函数，接收函数指针、初始区间、精度和最大迭代次数
    NonlinearEquationSolver(double (*func)(double), double a, double b, double epsilon = 1e-6, int max_iter = 100) :
        function(func), left(a), right(b), tolerance(epsilon), max_iterations(max_iter) {}

    // 使用二分法求解
    std::pair<double, bool> bisect() {
        if (left > right)
            return std::make_pair(right, false);

        double mid = (left + right) / 2.0;
        while (fabs(function(mid)) > tolerance && iterations() < max_iterations) {
            if (function(mid) * function(left) <= 0)
                right = mid;
            else
                left = mid;
            mid = (left + right) / 2.0;
        }
        return std::make_pair(mid, abs(function(mid)) <= tolerance);
    }

    // 使用牛顿迭代法求解
    std::pair<double, bool> newton() {
        double guess = (left + right) / 2.0;
        double prev_guess = guess;
        while (iterations() < max_iterations && abs(guess - prev_guess) > tolerance) {
            prev_guess = guess;
            guess -= function(guess) / derivative(guess);
        }
        return std::make_pair(guess, abs(guess - prev_guess) <= tolerance);
    
    private:
        double derivative(double x) const { // 假设导数已知或可以方便计算
            return 3 * x**2 - cos(x) - 4;
        }
        
        int iterations() const {
            return static_cast<int>(right - left) / 2 + 1;  // 计算区间长度作为近似迭代次数
        }
};

现在我们想要找出方程 `f(x) = x^3 - sin(x) - 4x + 1` 的所有实根，可以这样使用这个类：

double f(double x) { return x * x * x - sin(x) - 4 * x + 1; }
NonlinearEquationSolver solver(f, -10, 10);  // 初始化解空间

// 求解并打印结果
std::vector<double> roots;
if (auto result_bisect = solver.bisect()) {
    roots.push_back(result_bisect.first);
    if (result_bisect.second)
        std::cout << "Found root using bisection: " << result_bisect.first << std::endl;
}
if (auto result_newton = solver.newton()) {
    roots.push_back(result_newton.first);
    if (result_newton.second)
        std::cout << "Found root using Newton's method: " << result_newton.first << stdendl;
}

// 提示：实际应用中可能需要多次尝试以找到所有根，因为某些区域可能会有多个根
//