C++ 如何导入用户定义的函数

我试图创建一个程序，可以执行任何函数的数值积分。为此，用户需要能够指定需要集成的函数（代数）。目前，该函数定义为

f[i]=2*x[i]

。是否可以让用户输入该功能（使用

cin

或其他方法）

void fun（整数N，浮点x_min，浮点x_max，浮点*f，浮点*x）{
浮动deltaX=（x_max-x_min）/（N-1）；
x[0]=x_min；
对于（int i=0；i

我已经包括了程序的其余部分，因为前面提到的内容本身可能有点混乱：

#include<iostream>
#include<math.h>
using namespace std;

// Delaring functions
void fun(int N, float x_min, float x_max, float *f, float *x);

int main() {
    int N;                      // Number of nodes
    float x_min, x_max;         // Smallest and greatest value on the x-axis

    cin >> N;                   // Enter the number of nodes

    float *f = new float[N];
    float *x = new float[N];

    cin >> x_min;               // Enter smallest x-value
    cin >> x_max;               // Enter greatest x-value

    fun(N, x_min, x_max, f, x);

    // Dome some more stuff here (approximation / integration)!

    delete[] f;             // Remember to clear the pointer from the memory!
    delete[] x;             // Remember to clear the pointer from the memory!

    system("pause");
    return 0;
}

#包括
#包括
使用名称空间std；
//Delaring函数
虚空乐趣（整数N，浮点最小，浮点最大，浮点*f，浮点*x）；
int main（）{
int N；//节点数
浮动x_min，x_max；//x轴上的最小值和最大值
cin>>N；//输入节点数
浮动*f=新浮动[N]；
浮动*x=新浮动[N]；
cin>>x_min；//输入最小的x值
cin>>x_max；//输入最大x值
乐趣（N，x_最小值，x_最大值，f，x）；
//这里有更多的东西（近似/积分）！
delete[]f；//记住从内存中清除指针！
delete[]x；//记住从内存中清除指针！
系统（“暂停”）；
返回0；
}

您想接受用户输入，比如说一个

std:：string

，然后用

float操作符（）（float x）

。这是@MichaelWalz在评论中建议的“表达式评估器”

下面是一个简单的例子：

struct Expression 
{
    virtual float operator()(float x) const = 0;
}

struct LiteralExpression : public Expression 
{
    LiteralExpression (float data) : data(data)
    float operator()(float x) const { return data; }
private:
    float data;
}

struct XExpression : public Expression 
{
    float operator()(float x) const { return x; }
}

struct AddExpression : public Expression
{
    AddExpression (std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs) : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
    float operator()(float x) const { return lhs(x) + rhs(x); }
private:
    std::unique_ptr<Expression> lhs;
    std::unique_ptr<Expression> rhs;
}

struct MulExpression : public Expression
{
    MulExpression (std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs) : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
    float operator()(float x) const { return lhs(x) * rhs(x); }
private:
    std::unique_ptr<Expression> lhs;
    std::unique_ptr<Expression> rhs;
}

// more operations

std::unique_ptr<Expression> parse_expression(std::string input)
{
    // Order of construction here is precedence of expressions
    std::size_t mul_pos = input.find('*');
    if (mul_pos != input.npos)
    {
        std::unique_ptr<Expression> lhs = parse_expression(input.substr(0, mul_pos - 1));
        std::unique_ptr<Expression> rhs = parse_expression(input.substr(mul_pos + 1));
        return make_unique<MulExpression>(std::move(lhs), std::move(rhs));
    }

    std::size_t add_pos = input.find('*');
    if (add_pos != input.npos)
    {
        std::unique_ptr<Expression> lhs = parse_expression(input.substr(0, add_pos - 1));
        std::unique_ptr<Expression> rhs = parse_expression(input.substr(add_pos + 1));
        return make_unique<AddExpression>(std::move(lhs), std::move(rhs));
    }

    // Other expressions

    x_pos = input.find('x');
    if (x_pos != input.npos)
    {
         return make_unique<XExpression>();
    }

    float literal = stof(input);
    return make_unique<LiteralExpression>(literal);
}

struct表达式
{
虚拟浮点运算符（）（浮点x）常量=0；
}
struct LiteralExpression:公共表达式
{
文字表达式（浮点数据）：数据（数据）
浮点运算符（）（浮点x）常量{返回数据；}
私人：
浮动数据；
}
结构XExpression:公共表达式
{
浮点运算符（）（浮点x）常量{return x；}
}
struct AddExpression：公共表达式
{
AddExpression（std:：unique_ptr lhs，std:：unique_ptr rhs）：lhs（std:：move（lhs）），rhs（std:：move（rhs））{}
float操作符（）（float x）const{return lhs（x）+rhs（x）；}
私人：
std：：唯一的ptr lhs；
std：：唯一的ptr rhs；
}
结构表达式：公共表达式
{
多表达式（std：：unique_ptr lhs，std：：unique_ptr rhs）：lhs（std：：move（lhs）），rhs（std：：move（rhs））{}
浮点运算符（）（浮点x）常量{返回lhs（x）*rhs（x）；}
私人：
std：：唯一的ptr lhs；
std：：唯一的ptr rhs；
}
//更多操作
std:：unique_ptr parse_表达式（std:：string输入）
{
//这里的构造顺序是表达式的优先级
std:：size\u t mul\u pos=input.find（'*'）；
if（mul_pos！=input.npos）
{
std:：unique_ptr lhs=parse_表达式（input.substr（0，mul_pos-1））；
std:：unique_ptr rhs=parse_表达式（input.substr（mul_pos+1））；
返回make_unique（标准：：移动（lhs），标准：：移动（rhs））；
}
std:：size\u t add\u pos=input.find（'*'）；
如果（添加位置！=input.npos）
{
std:：unique_ptr lhs=parse_表达式（input.substr（0，add_pos-1））；
std:：unique_ptr rhs=parse_表达式（input.substr（add_pos+1））；
返回make_unique（标准：：移动（lhs），标准：：移动（rhs））；
}
//其他表达
x_pos=input.find（'x'）；
if（x_pos！=input.npos）
{
返回make_unique（）；
}
float literal=stof（输入）；
返回make_unique（文字）；
}

您想接受用户输入，比如说一个

std:：string

，然后用

float操作符（）（float x）

。这是@MichaelWalz在评论中建议的“表达式评估器”

下面是一个简单的例子：

struct Expression 
{
    virtual float operator()(float x) const = 0;
}

struct LiteralExpression : public Expression 
{
    LiteralExpression (float data) : data(data)
    float operator()(float x) const { return data; }
private:
    float data;
}

struct XExpression : public Expression 
{
    float operator()(float x) const { return x; }
}

struct AddExpression : public Expression
{
    AddExpression (std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs) : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
    float operator()(float x) const { return lhs(x) + rhs(x); }
private:
    std::unique_ptr<Expression> lhs;
    std::unique_ptr<Expression> rhs;
}

struct MulExpression : public Expression
{
    MulExpression (std::unique_ptr<Expression> lhs, std::unique_ptr<Expression> rhs) : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
    float operator()(float x) const { return lhs(x) * rhs(x); }
private:
    std::unique_ptr<Expression> lhs;
    std::unique_ptr<Expression> rhs;
}

// more operations

std::unique_ptr<Expression> parse_expression(std::string input)
{
    // Order of construction here is precedence of expressions
    std::size_t mul_pos = input.find('*');
    if (mul_pos != input.npos)
    {
        std::unique_ptr<Expression> lhs = parse_expression(input.substr(0, mul_pos - 1));
        std::unique_ptr<Expression> rhs = parse_expression(input.substr(mul_pos + 1));
        return make_unique<MulExpression>(std::move(lhs), std::move(rhs));
    }

    std::size_t add_pos = input.find('*');
    if (add_pos != input.npos)
    {
        std::unique_ptr<Expression> lhs = parse_expression(input.substr(0, add_pos - 1));
        std::unique_ptr<Expression> rhs = parse_expression(input.substr(add_pos + 1));
        return make_unique<AddExpression>(std::move(lhs), std::move(rhs));
    }

    // Other expressions

    x_pos = input.find('x');
    if (x_pos != input.npos)
    {
         return make_unique<XExpression>();
    }

    float literal = stof(input);
    return make_unique<LiteralExpression>(literal);
}

struct表达式
{
虚拟浮点运算符（）（浮点x）常量=0；
}
struct LiteralExpression:公共表达式
{
文字表达式（浮点数据）：数据（数据）
浮点运算符（）（浮点x）常量{返回数据；}
私人：
浮动数据；
}
结构XExpression:公共表达式
{
浮点运算符（）（浮点x）常量{return x；}
}
struct AddExpression：公共表达式
{
AddExpression（std:：unique_ptr lhs，std:：unique_ptr rhs）：lhs（std:：move（lhs）），rhs（std:：move（rhs））{}
float操作符（）（float x）const{return lhs（x）+rhs（x）；}
私人：
std：：唯一的ptr lhs；
std：：唯一的ptr rhs；
}
结构表达式：公共表达式
{
多表达式（std：：unique_ptr lhs，std：：unique_ptr rhs）：lhs（std：：move（lhs）），rhs（std：：move（rhs））{}
浮点运算符（）（浮点x）常量{返回lhs（x）*rhs（x）；}
私人：
std：：唯一的ptr lhs；
std：：唯一的ptr rhs；
}
//更多操作
std:：unique_ptr parse_表达式（std:：string输入）
{
//这里的构造顺序是表达式的优先级
std:：size\u t mul\u pos=input.find（'*'）；
if（mul_pos！=input.npos）
{
std:：unique_ptr lhs=parse_表达式（input.substr（0，mul_pos-1））；
std:：unique_ptr rhs=parse_表达式（input.substr（mul_pos+1））；
返回make_unique（标准：：移动（lhs），标准：：移动（rhs））；
}
std:：size\u t add\u pos=input.find（'*'）；
如果（添加位置！=input.npos）
{
std:：unique_ptr lhs=parse_表达式（input.substr（0，add_pos-1））；
std:：unique_ptr rhs=parse_表达式（input.substr（add_pos+1））；
返回make_unique（标准：：移动（lhs），标准：：移动（rhs））；
}
//其他表达
x_pos=input.find（'x'）；
if（x_pos！=input.npos）
{
返回make_unique（）；
}
float literal=stof（输入）；
返回make_unique（文字）；
}

研究脚本语言。您需要一个表达式计算器，编写一个表达式计算器并不简单，但也不太难。你应该可以