发布一个C++编写的自定义公式解析器

已于 2024-07-26 22:29:18 修改
阅读量531 收藏 1
点赞数 4
文章标签： c++ qt 开发语言
于 2024-07-24 19:58:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37206059/article/details/140671942
版权

由于项目需要，15年前自己用c++编写了一个简易的公式编辑器，支持+，-，*，/，函数，自定义变量等，非常实用，现在分享给大家.

calculateformula.h

#ifndef CALCULATEFORMULA_H
#define CALCULATEFORMULA_H

#include <functional>
#include <qstring.h>
#include <qstack.h>
#include <QVariant>
class CalculateFormula
{
public:
    constexpr static double MATH_PI = 3.14159265358979323846;
    using CallbackGetSymbolValue = std::function<double(const QString&, QVariant& value, bool& bOK)>;
    CalculateFormula(CallbackGetSymbolValue symbolHandler, QVariant value);

    bool Calculate(const QString& strFormula,double& dResult);
    QString GetPhrase(const QString& strPhrase,int& newIndex,int& type);
    double CalculateValue(double v1,double v2,int type,bool& bOk);
    double ToDouble(const QString& variable, bool& bOk);
    bool IsHighPriority(int type1,int type2);
    bool ProcessStackData(int type);
    QString * GetParam(const QString& Formula,  int& index,int countParam);
    double DoFunction(const QString& funName, const QString& Formula, int& index, bool& bOk);
    double CalculateSymbol(const QString& symbol, bool& bOk);
    static int GetCharType(const char c);

    double Sqrt(QString param [],bool& bOk);
    double Pow2(QString param [],bool& bOk);
    double Exp(QString param [],bool& bOk);
    double Abs(QString param [],bool& bOk);
    double Pow(QString param [],bool& bOk);
    double IsNull(QString param [],bool& bOk);
    double Log(QString param [],bool& bOk);
    double Sin(QString param [],bool& bOk);
    double Cos(QString param [],bool& bOk);
    double Tan(QString param [],bool& bOk);
    double Atan(QString param [],bool& bOk);
    double Atanr(QString param [],bool& bOk);
public:
    CallbackGetSymbolValue OnGetSymbolValue;
private:
    QStack<double> m_stkData;
    QStack<int> m_stkOperator;
    QString m_strErrorMessage="";
    QVariant m_objValue;
    short arrPriority[7][7]
        {
            //+,-,*,/,(,),=,
            /*+*/  { 0, 0,1,1,2,3,3},
            /*-*/  { 0, 0,1,1,2,3,3},
            /* * */{-1,-1,0,0,1,2,2},
            /* / */{-1,-1,0,0,1,2,2},
            /* ( */{-2,-2,-1,-1,0,1,1},
            /*  )*/{-3,-3,-2,-2,-1,0,0},
            /* =*/ {-3,-3,-2,-2,-1,0,0}
        };
};

#endif // CALCULATEFORMULA_H

calculateformula.cpp

#include "calculateformula.h"

CalculateFormula::CalculateFormula(CallbackGetSymbolValue symbolHandler, QVariant value)
{
    OnGetSymbolValue=symbolHandler;
    m_objValue=value;
}

double CalculateFormula::ToDouble(const QString& variable, bool& bOk)
{
    return variable.toDouble(&bOk);
}

/// <summary>
/// 判断type1的运算优先级是否大于type2的运算优先级
/// </summary>
/// <param name="type1"></param>
/// <param name="type2"></param>
/// <returns></returns>
bool CalculateFormula::IsHighPriority(int type1,int type2)
{
    if (arrPriority[type1][type2]<=0)
    {
        return true;
    }
    return false;
}

bool CalculateFormula::ProcessStackData(int type)
{
    bool bOk=false;
    if (m_stkOperator.count() == 0)
    {
        m_strErrorMessage = "表达式格式不正确";
        return false;
    }
    if (m_stkData.count() == 0)
    {
        m_strErrorMessage = "表达式格式不正确";
        return false;
    }

    int realType=m_stkOperator.pop();
    double v2=m_stkData.pop();
    while(true)
    {
        if (realType==4&&type==5)
        {
            break;
        }
        if (m_stkData.count()==0)
        {
            m_strErrorMessage="表达式格式不正确";
            return false;
        }
        v2=CalculateValue(m_stkData.pop(),v2,realType,bOk);
        if (!bOk)
        {
            return false;
        }
        if (m_stkOperator.count()>0)
        {
            if (type!=5)
            {
                if (IsHighPriority(m_stkOperator.top(),realType))
                {
                    realType=m_stkOperator.pop();
                    if (realType==4)
                    {
                        m_stkOperator.push(realType);
                        break;
                    }
                }
                else
                {
                    break;
                }
            }
            else
            {
                realType=m_stkOperator.pop();
            }
        }
        else
        {
            break;
        }
    }
    m_stkData.push(v2);
    if (type!=4&&type!=5)
    {
        m_stkOperator.push(type);
    }
    return true;
}

double CalculateFormula::Sqrt(QString param [],bool& bOk)
{
    bOk=true;
    double ret=0.0;
    CalculateFormula cf(OnGetSymbolValue,m_objValue);
    if (cf.Calculate(param[0], ret))
    {
        return sqrt(ret);
    }
    bOk = false;
    m_strErrorMessage = "函数Sqrt有错误" + param[0];
                        return 0.0;
}
double CalculateFormula::Pow2(QString param [],bool& bOk)
{
    bOk=true;
    double ret=0.0;
    CalculateFormula cf(OnGetSymbolValue, m_objValue);
    if (cf.Calculate(param[0], ret))
    {
        return ret*ret;
    }
    bOk = false;
    m_strErrorMessage = "函数POW2有错误" + param[0];
                        return 0.0;
}
double CalculateFormula::Sin(QString param [],bool& bOk)
{
    bOk = true;
    double ret = 0.0;
    CalculateFormula cf(OnGetSymbolValue, m_objValue);
    if (cf.Calculate(param[0],  ret))
    {
        return sin(ret);
    }
    bOk = false;
    m_strErrorMessage = "函数Sin有错误" + param[0];
                        return 0.0;
}
double CalculateFormula::Cos(QString param [],bool& bOk)
{
    bOk = true;
    double ret = 0.0;
    CalculateFormula cf(OnGetSymbolValue, m_objValue);
    if (cf.Calculate(param[0],  ret))
    {
        return cos(ret);
    }
    bOk = false;
    m_strErrorMessage = "函数Cos有错误" + param[0];
                        return 0.0;
}
double CalculateFormula::Tan(QString param [],bool& bOk)
{
    bOk = true;
    double ret = 0.0;
    CalculateFormula cf(OnGetSymbolValue, m_objValue);
    if (cf.Calculate(param[0],  ret))
    {
        return tan(ret);
    }
    bOk = false;
    m_strErrorMessage = "函数Tan有错误" + param[0];
                        return 0.0;
}
double CalculateFormula::Exp(QString param [],bool& bOk)
{
    bOk = true;
    double ret = 0.0;
    CalculateFormula cf(OnGetSymbolValue, m_objValue);
    if (cf.Calculate(param[0],  ret))
    {
        return exp(ret);
    }
    bOk = false;
    m_strErrorMessage = "函数Exp有错误" + param[0];
                        return 0.0;
}
double CalculateFormula::Atan(QString param [],bool& bOk)
{
    bOk = true;
    double ret = 0.0;
    CalculateFormula cf(OnGetSymbolValue, m_objValue);
    if (cf.Calculate(param[0],  ret))
    {
        return atan(ret);
    }
    bOk = false;
    m_strErrorMessage = "函数Atan[返回角度值]有错误" + param[0];
    return 0.0;
}
double CalculateFormula::Atanr(QString param [],bool& bOk)
{
    bOk = true;
    double ret = 0.0;
    CalculateFormula cf(OnGetSymbolValue, m_objValue);
    if (cf.Calculate(param[0],  ret))
    {
        return 360 / atan(ret) * MATH_PI;
    }
    bOk = false;
    m_strErrorMessage = "函数Atanr[反回弧度值]有错误" + param[0];
    return 0.0;
}
double CalculateFormula::Log(QString param [],bool& bOk)
{
    bOk = true;
    double ret1 = 0.0;
    double ret2 = 0.0;
    CalculateFormula cf_1(OnGetSymbolValue, m_objValue);
    CalculateFormula cf_2(OnGetSymbolValue, m_objValue);

    if (cf_1.Calculate(param[0],  ret1) && ret1 !=0 &&
        cf_2.Calculate(param[1],  ret2))
    {
        return log(ret1)/log(ret2);
    }
    bOk = false;
    m_strErrorMessage = "函数Log有错误:Log(" + param[0] + "," + param[1] + ")";
                        return 0.0;
}
double CalculateFormula::Pow(QString param [],bool& bOk)
{
    bOk = true;
    double ret1 = 0.0;
    double ret2 = 0.0;
    CalculateFormula cf_1(OnGetSymbolValue, m_objValue);
    CalculateFormula cf_2(OnGetSymbolValue, m_objValue);

    if (cf_1.Calculate(param[0],  ret1) &&
        cf_2.Calculate(param[1],  ret2))
    {
        return pow(ret1, ret2);
    }
    bOk = false;
    m_strErrorMessage = "函数Log有错误:Pow(" + param[0] + "," + param[1] + ")";
                        return 0.0;
}
double CalculateFormula::Abs(QString param [],bool& bOk)
{
    bOk = true;
    double ret = 0.0;
    CalculateFormula cf(OnGetSymbolValue, m_objValue);
    if (cf.Calculate(param[0],  ret))
    {
        return fabs(ret);
    }
    bOk = false;
    m_strErrorMessage = "函数Abs有错误" + param[0];
                        return 0.0;
}

double CalculateFormula::IsNull(QString param [],bool& bOk)
{
    bOk = true;
    double ret1 = 0.0;
    CalculateFormula cf_1(OnGetSymbolValue, m_objValue);
    CalculateFormula cf_2(OnGetSymbolValue, m_objValue);

    if (cf_1.Calculate(param[0],  ret1)) return ret1;
    if (cf_2.Calculate(param[1],  ret1)) return ret1;

    bOk = false;
    m_strErrorMessage = "函数IsNull有错误:IsNull(" + param[0] + "," + param[1] + ")";
                        return 0.0;
}

QString * CalculateFormula::GetParam(const QString& Formula,  int& index,int countParam)
{
                        int indexParam=0;
                        int countBrace=1;
                        QString * arrParam=new QString[countParam];
                        for(int i=0;i<countParam;i++){
        arrParam[i]=nullptr;
                        }
                        if (Formula[index]!='(')
                        {
        m_strErrorMessage = "表达式格式错误[缺少左括号]";
        return nullptr;
                        }
                        index++;
                        while (index<Formula.size())
                        {
        if (Formula[index]=='(')
        {
            countBrace++;
        }
        else if (Formula[index]==')')
        {
            countBrace--;
        }
        if (countBrace==0)
        {
            index++;
            break;
        }
        if (Formula[index]==',' && countBrace == 1)
        {
            indexParam++;
            index++;
            continue;
        }
        if (indexParam < countParam)
        {
            if (Formula[index] != ' ')
            {
                arrParam[indexParam] += Formula[index];
            }
        }
        index++;
                        }
                        if (indexParam<countParam && arrParam[countParam-1] != nullptr)
                        {
        return arrParam;
                        }
                        m_strErrorMessage = "表达式参数错误，应为"+QString::number(countParam)+"个参数";
                                            return nullptr;
}
double CalculateFormula::DoFunction(const QString& funName, const QString& Formula, int& index, bool& bOk)
{
    double val=0.0;
    bOk=true;
    QString fun=funName.toLower().trimmed();

    if (fun== "exp"){
        QString* strParam = GetParam(Formula,  index, 1);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Exp(strParam,  bOk);
        }
        delete[] strParam;

    } else         if (fun== "abs"){
        QString* strParam = GetParam(Formula,  index, 1);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Abs(strParam,  bOk);
        }
        delete[] strParam;

    }     else    if (fun== "pow"){
        QString* strParam = GetParam(Formula,  index, 2);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Pow(strParam,  bOk);
        }
        delete[] strParam;


    }   else      if (fun== "isnull"){
        QString* strParam = GetParam(Formula,  index, 2);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = IsNull(strParam,  bOk);
        }
        delete[] strParam;


    }    else     if (fun== "log"){
        QString* strParam = GetParam(Formula,  index, 2);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Log(strParam,  bOk);
        }
        delete[] strParam;


    }    else     if (fun== "sin"){
        QString* strParam = GetParam(Formula,  index, 1);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Sin(strParam,  bOk);
        }
        delete[] strParam;


    }     else    if (fun== "cos"){
        QString* strParam = GetParam(Formula,  index, 1);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Cos(strParam,  bOk);
        }
        delete[] strParam;


    }    else     if (fun== "tan"){
        QString* strParam = GetParam(Formula,  index, 1);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Tan(strParam,  bOk);
        }
        delete[] strParam;


    }   else      if (fun== "atanr"){
        QString* strParam = GetParam(Formula,  index, 1);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Atanr(strParam,  bOk);
        }
        delete[] strParam;


    }    else     if (fun== "sqrt"){
        QString* strParam = GetParam(Formula,  index, 1);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Sqrt(strParam,  bOk);
        }
        delete[] strParam;


    }    else     if (fun== "pow2"){
        QString* strParam = GetParam(Formula,  index, 1);
        if (strParam==nullptr)
        {
            bOk = false;
        } else {
            val = Pow2(strParam,  bOk);
        }
        delete[] strParam;


    } else {
        m_strErrorMessage="不支持的函数"+funName;
        bOk=false;
    }
    return val;
}
double CalculateFormula::CalculateSymbol(const QString& symbol, bool& bOk)
{
    bOk=false;
    if (OnGetSymbolValue!=nullptr)
    {
        double ret=OnGetSymbolValue(symbol,m_objValue, bOk);
        if (!bOk)
        {
            m_strErrorMessage="没有定义的变量"+symbol;
            return 1.0;
        }
        return ret;
    }
    m_strErrorMessage="本程序不能计算变量"+symbol;
    return 1.0;
}
bool CalculateFormula::Calculate(const QString& strFormula,double& dResult){
    int    index=0;
    int    type=-1;
    bool   bOk=false;
    double dTemp=0.0;
    QString strPhrase=GetPhrase(strFormula,index,type);
    dResult=0.0;
    m_stkData.clear();
    m_stkOperator.clear();
    while (strPhrase!="")
    {
        m_strErrorMessage+=strPhrase;
        switch(type)
        {
        case 9:
            dTemp=DoFunction(strPhrase,strFormula,index, bOk);
            if (!bOk)
            {
                return false;
            }
            m_stkData.push(dTemp);
            break;
        case 7:
            dTemp=ToDouble(strPhrase, bOk);
            if (!bOk)
            {
                m_strErrorMessage="表达式输入有误"+strPhrase;
                return false;
            }
            m_stkData.push(dTemp);
            break;
        case 8:
            dTemp=CalculateSymbol(strPhrase, bOk);
            if (!bOk)
            {

                return false;
            }
            m_stkData.push(dTemp);
            break;
        default:
            if (type>=0&&type<=6)
            {
                if (m_stkOperator.empty())
                {
                    m_stkOperator.push(type);
                }
                else
                {
                    if ((type==4||m_stkOperator.top()==4||!IsHighPriority(m_stkOperator.top(),type)) && type!=5)
                    {
                        m_stkOperator.push(type);
                    }
                    else
                    {
                        if (!ProcessStackData(type))
                        {
                            return false;
                        }
                    }
                }
            }
            else
            {
                m_strErrorMessage="不支持的运算符"+strPhrase;
                return false;
            }
            break;
        }
        strPhrase=GetPhrase(strFormula,index,type);
    }
    if (m_stkData.count()>0)
    {
        dResult=m_stkData.pop();
    }
    index=0;
    while(!m_stkOperator.empty())
    {
        if (m_stkData.empty())
        {
            m_strErrorMessage="表达式不正确";
            return false;
        }
        int tType=m_stkOperator.pop();
        if (tType==5)
        {
            index++;
        }
        else if (tType==4)
        {
            index--;
        }
        dResult=CalculateValue(m_stkData.pop(),dResult,tType,bOk);
        if (!bOk)
        {
            return false;
        }
    }
    return true;
}

double CalculateFormula::CalculateValue(double v1,double v2,int type,bool& bOk)
{
    bOk=true;
    switch(type)
    {
    case 0:
        return v1+v2;
    case 1:
        return v1-v2;
    case 2:
        return v1*v2;
    case 3:
        if (v2==0)
        {
            m_strErrorMessage=QObject::tr("除数为零");
            bOk=false;
            return 0;
        }
        return v1/v2;
    }
    m_strErrorMessage=QObject::tr("未知错误:%1").arg(type);
    bOk=false;
    return 0.0;
}

int CalculateFormula::GetCharType(const char c)
{
    switch(c)
    {
    case '+':
        return 0;
    case '-':
        return 1;
    case '*':
        return 2;
    case '/':
        return 3;
    case '(':
        return 4;
    case ')':
        return 5;
    case '=':
        return 6;
    default:
        if ((c>='0'&&c<='9')||c=='.')
        {
            return 7;// is number
        }
        break;
    }
    return 8;//is char
}

QString CalculateFormula::GetPhrase(const QString& strPhrase,int& newIndex,int& type)
{
    QString strTemp="";
    int i=newIndex;
    int ret=-1;
    type=-1;
    bool bSecondDispare=false;
    if (strPhrase.isEmpty() || strPhrase.size()<=newIndex)
    {
        return "";
    }
    ret=GetCharType(strPhrase[i].toLatin1());
    if (ret==1||ret==0)
    {
        if (i==0)
        {
            do
            {
                strTemp+=strPhrase[i];
                i++;
                if (i>=strPhrase.size())
                {
                    break;
                }
                if ((strPhrase[i]=='E'||strPhrase[i]=='e')&&!bSecondDispare)
                {
                    bSecondDispare=true;
                    strTemp+='E';
                    i++;
                    if (i>=strPhrase.size())
                    {
                        break;
                    }
                    if (strPhrase[i]=='+'||strPhrase[i]=='-')
                    {
                        strTemp+=strPhrase[i];
                        i++;
                        if (i>=strPhrase.size())
                        {
                            break;
                        }
                    }

                }

            }while(GetCharType(strPhrase[i].toLatin1())==7);
            newIndex=i;
            type=7;
            return strTemp;
        }
        else if (GetCharType(strPhrase[i-1].toLatin1())>=0&&GetCharType(strPhrase[i-1].toLatin1())<=4)
        {
            do
            {
                strTemp+=strPhrase[i];
                i++;
                if (i>=strPhrase.size())
                {
                    break;
                }
                if ((strPhrase[i]=='E'||strPhrase[i]=='e')&&!bSecondDispare)
                {
                    bSecondDispare=true;
                    strTemp+='E';
                    i++;
                    if (i>=strPhrase.size())
                    {
                        break;
                    }
                    if (strPhrase[i]=='+'||strPhrase[i]=='-')
                    {
                        strTemp+=strPhrase[i];
                        i++;
                        if (i>=strPhrase.size())
                        {
                            break;
                        }
                    }

                }

            }while(GetCharType(strPhrase[i].toLatin1())==7);
            newIndex=i;
            type=7;
            return strTemp;
        }
        else
        {
            type=ret;
            newIndex=i+1;
            return strPhrase[i];
        }
    }
    else if (ret>=0&&ret<=6)
    {
        type=ret;
        newIndex=i+1;
        return strPhrase[i];
    }
    else if (ret==7)
    {
        do
        {
            strTemp+=strPhrase[i];
            i++;
            if (i>=strPhrase.size())
            {
                break;
            }
            if ((strPhrase[i]=='E'||strPhrase[i]=='e')&&!bSecondDispare)
            {
                bSecondDispare=true;
                strTemp+='E';
                i++;
                if (i>=strPhrase.size())
                {
                    break;
                }
                if (strPhrase[i]=='+'||strPhrase[i]=='-')
                {
                    strTemp+=strPhrase[i];
                    i++;
                    if (i>=strPhrase.size())
                    {
                        break;
                    }
                }

            }
        }while(GetCharType(strPhrase[i].toLatin1())==7);
        newIndex=i;
        type=ret;
        return strTemp;
    }
    else if (ret==8)
    {
        do
        {
            strTemp+=strPhrase[i];
            i++;
            if (i>=strPhrase.size())
            {
                break;
            }
        }while(GetCharType(strPhrase[i].toLatin1())>=7);
        newIndex=i;
        if (i<strPhrase.size()&&strPhrase[i]=='(')
        {
            type=9;
        }
        else
        {
            type=ret;
        }
        return strTemp;
    }
    return "";
}

使用方法


double s(const QString& symbol, QVariant& v, bool& bOK){
    if (symbol=="a"){
        bOK=true;
        return 1;
    }
    if (symbol=="b"){
        bOK=true;
        return 2;
    }
    bOK=false;
    return 0;
}

QVariant vv;//对应变量值获取函数中的参数v
    double dRet;
    CalculateFormula f(s,vv);
    f.Calculate("a+b", dRet);
    QMessageBox::information(nullptr,"",QString::number(dRet));

王子章_18627782678
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于MFC计算器
anlu_的博客
08-31 242
基于MFC计算器（基础点） 主要是在实现MFC计算器的过程中碰到的一些问题，和补充的一些知识。 需求：把计算器运算的过程呈现出来。 想法：利用两个队列，一个存储输入的字符串（表达式），一个存放结果。 分别命名为queue1，和myqueue，让字符串从左到右依次入队列。 但之后按照自己的思路去推演，发现如果进入队列的是1+23，如果下一个字符入队的是“+”，那么先计算23的结果入队myqueue中，而queue1中还储存1，但下一个“+”入 queue1之后，此时queue1中包含1+，最后把myqueu
C++实现计算器中的算式解析类+demo演示
06-26
用面向对象的方法来实现解析类, 该类可以处理复杂算式解析(包括多参数的数学函数)
MFC计算器包含表达式计算
07-25
基于MFC的计算器，能够完成各种功能的计算，
基于MFC编程的计算器
Leo的历练之道
04-21 3135
欢迎大家和我交流，有什么不懂的，留言即可，想要计算器的，也可以通过留言告诉我。 2.1MFC计算器操作与功能    本计算器操作简单，且完全是自己编制出来的，直接点击即可输入相应数字，然后选择相应运算即可求出相应结果。对于功能，本计算器可以实现连续运算，无论数的多少，而且只分先后，不分优先级。第二个功能是可以输入括号，这是帮助实现优先级的。第三个功能是能够输入小数，进行小数的运算。还有就是可以输入
【C++ 学习笔记】自定义函数计算Π
weixin_45817597的博客
05-05 1275
文章目录一、Π的计算公式二、题目分解三、实现步骤1.函数声明2.函数定义3.主函数注意事项 一、Π的计算公式 二、题目分解 题目可以分解为两个函数。分别为求幂次函数和求反正切函数。 三、实现步骤 1.函数声明 代码如下（示例）： #include <iostream> using namespace std; double power(double x, int num); double arctan(double x); double get_pai(); 2.函数定义 代码如
公式解析结算
10-24
总的来说，“公式解析结算”是一个涉及到编程语言、解析理论、数学和软件工程多个领域的技术问题。理解和实现这样的系统需要对C++语法、解析算法、数值计算和异常处理有深入的了解。对于有兴趣的开发者来说，这是一...
公式解析器，相信大家都期待拥有
04-21
今天我们要探讨的是一款名为“MTParser”的公式解析器，它以其强大的功能和灵活性，为用户提供了自定义和扩展的可能性，非常适合学习和非商业使用。 MTParser，全称为MathTextParser，是由Matthias Troeger开发的一...
n-body-solver:一个简单的C ++中的n体求解器
03-20
本文将详细探讨一个基于C++实现的简单n体求解器。 C++是一种通用的、面向对象的编程语言，因其高效性和灵活性而常被用于科学计算领域。在这个n-body-solver项目中，开发者使用C++来构建一个能够模拟多个质点在引力...
简易公式运算器.zip
01-02
本篇文章将深入探讨一个名为“简易公式运算器”的项目，这是一个利用QT框架开发的轻量级应用，它允许用户输入自定义的数学公式并进行计算。我们将从QT编程基础、公式解析、程序图标修改以及发行版打包等多个方面来...
浙大c++教材ppt，非常详细
04-11
- **链接**：将多个目标文件组合成一个可执行文件，文件扩展名为`.exe`。 - **运行**：执行编译好的程序。 **1.5 集成开发环境(IDE)** - **定义**：集成多种功能于一体的软件开发工具，包括但不限于编辑、编译、...
c++ 简单数学公式计算
12-16
该软件有c++语言编写，实现了对数学公式计算。如（45+78）*45-9 等，没有涉及异常处理
c++自定义函数
liuhaiguanglala的博客
03-13 5737
对于小型应用程序来说不设计自定义函数完全可行，但随着程序越来越大，越来越复杂，实现的功能越来越多，如果不使用函数，main函数将变的越来越复杂越来越雍肿越来越令人难懂，而在更改程序的每一个功能的时候，往往要对整个main函数继续修改，所以在程序设计中，函数的设计与调用是很重要的一个部分。 例1：计算一个正方形的面积 #include<iostream> using namespace std; int area(int x) { return x*x; } int main()
C++ 自定义函数 入门
Commander_WingT的博客
12-23 1万+
学C++语言的同学们！ 你是否在为自己的程序只有main()的主函数而觉得乏味枯燥？ 你是否在为自己程序进行多次相同运算时，而在拼命复制代码而抓狂？ 来建立一个自己的函数(function)吧！ int 这里写函数名(这里列举函数需要另外输入的值) { 这里是执行的代码段 return 返回的值; } 看不大懂？没关系。直接看实例吧！ #inclu...
C++函数的定义与使用
热门推荐
跟着BOSS有肉吃
03-03 4万+
函数的定义和使用main就是一个函数，它是C++程序的主函数。一个C++程序可以由一个主函数和若干子函数组成。主函数是程序执行的开始点。由主函数调用子函数，子函数还可以再调用其它子函数。调用其它函数的函数称为主调函数。被其他函数调用的函数称为被调函数。一个函数很可能既调用别的函数又被其它函数调用。1.函数的定义1.1函数定义的语法形式类型说明符   函数名（含类型说明的形式参数表）{   语句序列...
C++中的自定义函数
沛沛霖的博客
04-25 7666
在C++中我们可以使用C++中的库，也可以使用C++中的​系统命令，但是这些东西真的能够满足小编的野心吗？答案是否定的！这是因为我们自己需要的算法可能在一个程序里面调用N多次，但是库或者系统中没有这种算法，所以我们就会不停的Ctrl+C以及Ctrl+V，这样出来的程序虽然行数非常多，但是这个程序是废物，这也就是为什么小编这期要写自定义函数这一期的理由啦！
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 138
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++笔记5•内存管理•
qq_64446190的博客
08-12 1072
内存管理
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 174
C++ | Leetcode C++题解之第337题打家劫舍III
qt/c++编写自定义控件源码
12-08
Qt/C++是一种开发桌面应用程序的跨平台开发框架，它提供了丰富的工具和类库，能够方便快捷地编写自定义控件源码。 首先，我们需要创建一个继承自QWidget或QFrame的类来实现自定义控件。在这个类中，我们可以重载一些事件处理函数来实现控件的特定功能，比如绘制事件函数paintEvent()、鼠标事件函数mousePressEvent()等等。通过这些函数，我们可以控制控件的外观、响应用户输入等。 在实现自定义控件的外观时，可以利用Qt提供的各种绘图工具和API。例如，可以使用QPainter类来绘制各种形状、图像、文字等，还可以使用QPen和QBrush类来设置绘制的样式和颜色。通过这些工具，我们可以实现各种个性化的外观效果，如圆角、渐变、阴影等。 对于自定义控件的功能实现，可以根据需求使用Qt提供的各种功能模块。比如，使用QTimer类实现定时器功能，使用QMediaPlayer类实现音视频播放功能等等。此外，Qt还提供了一系列的信号和槽机制，可以方便地实现控件之间的交互和通信。 在自定义控件的使用方面，可以通过在其他QWidget中使用该控件的对象的方式来使用它。将自定义控件放入项目中，然后在界面中添加该控件的实例对象，即可展示该控件，并与其交互。也可以通过在UI界面设计软件中将该控件拖拽到需要的位置上，然后使用信号槽机制来实现与其他控件的交互。 总之，Qt/C++编写自定义控件源码需要熟悉Qt的基本概念和API，并结合自身的需求来设计和实现控件的外观和功能。通过合理的设计和编码，可以创建出各种各样的自定义控件，丰富应用程序的界面和功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值