能否使用数学表达式作为参数构建Polynomial类对象？

要在C++里实现接近4(x^3) + 2(x^2) - 8的语法来构建Polynomial对象，需要通过运算符重载实现语法糖，以下是具体可行方案：

1. 基础类定义 #

先定义Variable（变量）和Term（多项式项）两个基础类：

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>

class Variable {
public:
    std::string name;
    Variable(const char* n) : name(n) {}
};

class Term {
public:
    int coeff;
    std::string var;
    int exp;

    // 常数项构造（指数为0）
    Term(int c) : coeff(c), var(""), exp(0) {}
    // 带变量的项构造
    Term(int c, const std::string& v, int e) : coeff(c), var(v), exp(e) {}
};

2. 运算符重载实现语法糖 #

（1）重载operator^实现变量幂运算 #

让变量和整数的^运算返回一个系数为1的项：

Term operator^(const Variable& v, int exp) {
    return Term(1, v.name, exp);
}

（2）重载operator*实现系数与项的相乘 #

支持整数和Term相乘，生成对应系数的多项式项：

Term operator*(int coeff, const Term& term) {
    return Term(coeff * term.coeff, term.var, term.exp);
}

注：C++不允许整数直接作为可调用对象（即4(...)这种写法不符合语法），所以用4*(x^3)替代你想要的4(x^3)，这是最接近需求且合法的写法。

（3）Polynomial类实现及加减运算支持 #

class Polynomial {
private:
    std::vector<Term> terms;

    // 合并同类项辅助函数
    void combineLikeTerms() {
        // 合并相同变量和指数的项
        for (size_t i = 0; i < terms.size(); ++i) {
            for (size_t j = i + 1; j < terms.size();) {
                if (terms[i].var == terms[j].var && terms[i].exp == terms[j].exp) {
                    terms[i].coeff += terms[j].coeff;
                    terms.erase(terms.begin() + j);
                } else {
                    ++j;
                }
            }
        }
        // 移除系数为0的项
        terms.erase(std::remove_if(terms.begin(), terms.end(),
            [](const Term& t) { return t.coeff == 0; }), terms.end());
    }

public:
    Polynomial() = default;
    // 从Term构造多项式
    Polynomial(const Term& t) {
        terms.push_back(t);
        combineLikeTerms();
    }
    // 从整数构造常数多项式
    Polynomial(int constant) {
        terms.emplace_back(constant);
        combineLikeTerms();
    }

    // 重载operator+：多项式加项
    Polynomial operator+(const Term& t) const {
        Polynomial res = *this;
        res.terms.push_back(t);
        res.combineLikeTerms();
        return res;
    }
    // 重载operator+：多项式加常数
    Polynomial operator+(int constant) const {
        return *this + Term(constant);
    }

    // 重载operator-：多项式减项
    Polynomial operator-(const Term& t) const {
        Polynomial res = *this;
        Term neg_t(-t.coeff, t.var, t.exp);
        res.terms.push_back(neg_t);
        res.combineLikeTerms();
        return res;
    }
    // 重载operator-：多项式减常数
    Polynomial operator-(int constant) const {
        return *this - Term(constant);
    }

    // 打印多项式
    void print() const {
        if (terms.empty()) {
            std::cout << "0";
            return;
        }
        bool first = true;
        for (const auto& t : terms) {
            if (!first) {
                std::cout << (t.coeff > 0 ? " + " : " - ");
            } else {
                first = false;
                if (t.coeff < 0) std::cout << "-";
            }
            int abs_coeff = std::abs(t.coeff);
            if (t.exp == 0) {
                std::cout << abs_coeff;
            } else {
                if (abs_coeff != 1) std::cout << abs_coeff;
                std::cout << t.var;
                if (t.exp != 1) std::cout << "^" << t.exp;
            }
        }
        std::cout << std::endl;
    }
};

3. 使用示例 #

现在可以用接近需求的语法创建并操作多项式：

int main() {
    Variable x("x");

    // 构建多项式：4x³ + 2x² -8
    Polynomial p = 4*(x^3) + 2*(x^2) - 8;
    p.print(); // 输出：4x^3 + 2x^2 - 8

    return 0;
}

额外说明 #

如果一定要强行模拟4(x^3)的写法，可以通过宏实现，但宏会带来语法歧义、调试困难等问题，不推荐使用：

#define MUL(coeff, term) (coeff * term)
// 使用方式：MUL(4, x^3)

内容的提问来源于stack exchange，提问作者Noel19283746