c++ 稀疏多项式计算器（可视化操作——鼠标点击型菜单）

最新推荐文章于 2023-09-29 14:28:13 发布
最新推荐文章于 2023-09-29 14:28:13 发布
阅读量522 收藏 5
点赞数
分类专栏： 功能性项目 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57404161/article/details/120419913
版权

写了大作业，来水一贴。这次使用了stl中的双链表管理数据。

 1 功能介绍

  • 输入多项式
  • 多项式加法
  • 多项式减法
  • 多项式乘法
  • 多项式求值
  • 多项式求导

2 分析

(1)定义单项式结构体，包含系数与指数。
(2)多项式频繁增删，应使用链表存储。
(3)多项式加减法：本质上是合并链表，时间复杂度o(m + n)
(4)多项式乘法：用双重循环遍历两个多项式，最后排序，合并同类项，时间复杂度o(n2)
(5)多项式求导、求值：时间复杂度o(n)

3 设计

struct node
{
    double coefficient_;
    int exponent_;
};

class Poly
{
private:
    list<node> ploy_;

public:
    Poly();
    Poly(const string x);
    Poly(const Poly &x);
    Poly(const list<node> &x);

    Poly operator+(const Poly &x) const;
    Poly operator-(const Poly &x) const;
    Poly operator*(const Poly &x) const;
    double value(double x) const;   //求值
    Poly derivative() const;        //求导
    friend ostream &operator<<(ostream &pout, const Poly &x);
};

#endif

4 代码

4.1 poly.hpp

#ifndef POLY_HPP
#define POLY_HPP
#include <list>
#include <iostream>
#include <sstream>
#include <cmath>
using namespace std;
struct node
{
    double coefficient_;
    int exponent_;
    node(double a = 0, int n = 0) : coefficient_(a), exponent_(n){};
    node(const node &x) : coefficient_(x.coefficient_), exponent_(x.exponent_){};
    bool operator<(const node &x) { return exponent_ < x.exponent_; }         //for sort
    bool operator==(const node &x) { return coefficient_ == x.coefficient_; } //for erase
};

void combine(list<node> &x) //合并相邻的同类项
{
    auto p = x.begin();
    auto last = p++;
    while (p != x.end())
    {
        if (last->exponent_ == p->exponent_)
        {
            p->coefficient_ += last->coefficient_;
            if (p->coefficient_ == 0)
                p++;
            x.erase(last, p);
            last = p++;
        }
        else
        {
            last++;
            p++;
        }
    }
};

class Poly
{
private:
    list<node> ploy_;

public:
    Poly(){};
    Poly(const string x) { init(x); }
    Poly(const Poly &x)
    {
        for (auto &p : x.ploy_)
            ploy_.push_back(p);
    };
    Poly(const list<node> &x)
    {
        for (auto p : x)
            ploy_.push_back(p);
    }
    ~Poly(){};

    void init(string x)
    {
        istringstream sin(x);
        double a;
        int n;
        while (sin.peek() != '#' && sin.peek() != EOF)
        {
            sin >> a >> n;
            if (a != 0)
                ploy_.push_back({a, n});
        }
        ploy_.sort();
    };
    Poly operator+(const Poly &x) const
    {
        list<node> left(this->ploy_), right(x.ploy_);
        left.merge(right);
        combine(left);
        return Poly(left);
    };
    Poly operator-(const Poly &x) const
    {
        list<node> left(this->ploy_), right(x.ploy_);
        for (auto &p : right)
            p.coefficient_ = -p.coefficient_;
        left.merge(right);
        combine(left);
        return Poly(left);
    }
    Poly operator*(const Poly &x) const
    {
        list<node> temp;
        for (auto p = ploy_.begin(); p != ploy_.end(); p++)
            for (auto q = x.ploy_.begin(); q != x.ploy_.end(); q++)
                temp.push_back(node(p->coefficient_ * q->coefficient_, p->exponent_ + q->exponent_));
        temp.sort();
        combine(temp);
        return Poly(temp);
    }
    double value(double x) const    //求值
    {
        double temp = 0;
        for (auto p : ploy_)
            temp += p.coefficient_ * pow(x, p.exponent_);
        return temp;
    }
    Poly derivative() const        //求导
    {
        list<node> temp;
        auto p = ploy_.begin();
        if (p->exponent_ == 0)
            p++;
        for (; p != ploy_.end(); p++)
            temp.push_back(node(p->coefficient_ * p->exponent_, p->exponent_ - 1));
        return Poly(temp);
    }
    friend ostream &operator<<(ostream &pout, const Poly &x)
    {
        if (x.ploy_.size())
        {
            auto p = x.ploy_.rbegin();
            cout << p->coefficient_ << "x^" << p->exponent_;
            for (p++; p != x.ploy_.rend(); p++)
            {
                cout << " + ";
                if (p->coefficient_ != 1 || p->exponent_ == 0) //系数不为1 || 常数项
                    cout << p->coefficient_;
                if (p->exponent_) //不为常数项
                {
                    cout << 'x';
                    if (p->exponent_ != 1) //有指数
                        cout << '^' << p->exponent_;
                }
            }
        }
        else
            pout << 0;
        return pout;
    }
};

#endif

 4.2 console.hpp

#ifndef CONSOLE_HPP
#define CONSOLE_HPP
#include <windows.h>
#include <conio.h>
#include <iostream>
#include <iomanip>
using std::ios_base;
using std::ostream;
//dwButtonState 鼠标按钮状态
#define L_BUTTON 0x1
#define R_BUTTON 0x2

// dwEventFlags 鼠标事件状态
#define MOUSE_CLICK 0x0
#define MOUSE_MOVED 0x1
#define DOUBLE_CLICK 0x2

//颜色
#define COLOR_default SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x07);
#define COLOR_Black_Cyan SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0b);
#define COLOR_Yellow_Blue SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0xe9);

// 光标位置
// 移动光标位置
inline void setcursor(short x = 0, short y = 0)
{
    COORD temp = {x, y};
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), temp);
}
inline void setcursor(const COORD &temp)
{
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), temp);
}

// 获得光标位置
inline void getcursor(COORD &other)
{
    CONSOLE_SCREEN_BUFFER_INFO temp;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &temp);
    other = temp.dwCursorPosition;
}
inline COORD getcursor()
{
    CONSOLE_SCREEN_BUFFER_INFO temp;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &temp);
    return temp.dwCursorPosition;
}

//比较坐标
inline bool operator==(COORD a, COORD b)
{
    return a.X == b.X && a.Y == b.Y;
};
inline bool operator!=(COORD a, COORD b)
{
    return !(a == b);
}

//输出光标坐标
ostream &operator<<(ostream &pout, const COORD &temp)
{
    pout.setf(ios_base::fixed);
    pout << "[Cursor Position] X: " << std::setw(2) << temp.X << "  Y: " << std::setw(2) << temp.Y;
    return pout;
}

//是否隐藏光标
void hidecursor(bool hide = true)
{
    CONSOLE_CURSOR_INFO CursorInfo;
    GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &CursorInfo);
    CursorInfo.bVisible = !hide;
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &CursorInfo);
}

// 更改控制台设置，防止控制台属性导致的判定失败
void setmode()
{
    DWORD mode;
    GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &mode);
    mode &= ~ENABLE_QUICK_EDIT_MODE; //移除快速编辑模式
    mode &= ~ENABLE_INSERT_MODE;     //移除插入模式
    // mode &= ~ENABLE_MOUSE_INPUT;     //移除鼠标输入
    SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), mode);
}

//判断鼠标点击位置是否在指定的有效范围（本行，本列至5列之间）
bool operator<=(const COORD &button, const COORD &click)
{
    if (button.Y == click.Y && button.X <= click.X && click.X <= button.X + 20)
        return true;
    else
        return false;
};
//等待鼠标事件，可排除鼠标移动
MOUSE_EVENT_RECORD waitmouse(bool move = true)
{
    INPUT_RECORD record; //输入事件
    DWORD reg;           //临时寄存
    while (1)
    {
        Sleep(10);
        ReadConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &record, 1, &reg);                                  //将输入事件存入record
        if (record.EventType == MOUSE_EVENT && (move | record.Event.MouseEvent.dwEventFlags != MOUSE_MOVED)) //是鼠标事件 && 移动事件与模式对应
            return record.Event.MouseEvent;
    }
}
// 清屏函数
void clean(int a = 0)
{
    int temp = a ? a : getcursor().Y;
    setcursor(0, 0);
    for (int i = 0; i <= temp; i++)
        std::cout << std::string(100, ' ') << '\n';
    setcursor(0, 0);
}
//暂停
void pause()
{
    std::cout << "请按任意键继续\n";
    std::cin.sync();
    std::cin.get();
}

#endif

4.3 menu.hpp

#ifndef MENU_HPP
#define MENU_HPP
#include "console.hpp"
#include <vector>
using std::cout;
using std::endl;
using std::string;
using std::vector;

#define show_real(x) cout << #x ": " << x << '\n'
//button - click
class Menu
{
private:
    struct node
    {
        void (*pfunc_)();
        string display_;
        COORD pos_;
    };
    vector<node> nodes_;
    string title_;

protected:
    void init_pos()
    {
        for (auto p = nodes_.begin(); p != nodes_.end(); p++)
        {
            getcursor(p->pos_);
            cout << p->display_ << "\n\n";
        }
    };

    bool implement(COORD clickpos)
    {
        waitmouse(false); //过滤鼠标松开
        for (auto p = nodes_.begin(); p != nodes_.end(); p++)
        {
            if (p->pos_ <= clickpos) //点击成功
            {
                hidecursor(0);
                clean();
                p->pfunc_();
                hidecursor(1);
                cout << "\n\n鼠标点击任意位置以继续\n";
                waitmouse(false);
                highlight({0, 0});
                return true;
            }
        }
        return false;
    };
    void highlight(COORD hang)
    {
        clean();
        cout << title_ << endl //显示内容
             << "========================================" << endl;
        for (auto p = nodes_.begin(); p != nodes_.end(); p++)
        {
            if (p->pos_ <= hang) //悬停点
            {
                COLOR_Black_Cyan;
                cout << p->display_ << "\n\n";
                COLOR_default;
            }
            else
                cout << p->display_ << "\n\n";
        }
    }

public:
    //constructor
    Menu(){};
    ~Menu(){};
    //methods
    Menu &settitle(string s)
    {
        title_ = s;
        return *this;
    }

    Menu &add(void (*p)() = nullptr, string d = "Unkown.")
    {
        nodes_.push_back({p, d});
        return *this;
    };

    void start()
    {
        MOUSE_EVENT_RECORD mouse;
        setmode();
        hidecursor(1);
        clean();
        cout << title_ << endl //显示内容
             << "========================================" << endl;
        init_pos(); //记录位置
        do
        {
            Sleep(10); //减少次数
            mouse = waitmouse();
            if (mouse.dwEventFlags == MOUSE_MOVED)
                highlight(mouse.dwMousePosition);
            else if (mouse.dwButtonState == L_BUTTON)
                implement(mouse.dwMousePosition);
        } while (mouse.dwButtonState != R_BUTTON);
        Sleep(100); //过滤
    };
};
#endif

4.4 主函数

#include "poly.hpp"
#include "menu.hpp"
#include <iostream>
using namespace std;
void show1();
void show2();
void show11(); //+
void show12(); //-
void show13(); //*
void show14(); //`
void show15(); //求值
int main()
{
    Menu loop;
    loop.settitle("多项式计算器（右键退出）");
    loop.add(show1, "开始计算").add(show2, "功能演示");
    loop.start();
}
void show2()
{
    cout << "输入格式：\n"
            "先输入系数，再输入指数，使用空格分隔开；输入完按回车\n"
            "如：\n"
            "输入: 1.1 2 3.3 4\n"
            "表示： 1.1x^2 + 3.3x^4\n"
            "你并不需要降次输入，程序会完成整理过程\n";
    Sleep(1000);
}

void show1()
{
    Menu cal;
    cal.settitle("请选择功能");
    cal.add(show11, "多项式加法").add(show12, "多项式减法").add(show13, "多项式乘法");
    cal.add(show14, "多项式求导").add(show15, "多项式求值");
    cal.start();
}

void show11() //+
{
    Poly left, right;
    {
        char temp[101];
        cout << "请输入左多项式：";
        cin.getline(temp, 100);
        left.init(temp);
        cout << "请输入右多项式：";
        cin.getline(temp, 100);
        right.init(temp);
    }
    show_real(left);
    show_real(right);
    show_real(left + right);
}
void show12() //-
{
    Poly left, right;
    {
        char temp[101];
        cout << "请输入左多项式：";
        cin.getline(temp, 100);
        left.init(temp);
        cout << "请输入右多项式：";
        cin.getline(temp, 100);
        right.init(temp);
    }
    show_real(left);
    show_real(right);
    show_real(left - right);
};
void show13() //*
{
    Poly left, right;
    {
        char temp[101];
        cout << "请输入左多项式：";
        cin.getline(temp, 100);
        left.init(temp);
        cout << "请输入右多项式：";
        cin.getline(temp, 100);
        right.init(temp);
    }
    show_real(left);
    show_real(right);
    show_real(left * right);
}
void show14() //`
{
    Poly polynomial;
    {
        char temp[101];
        cout << "请输入多项式：";
        cin.getline(temp, 100);
        polynomial.init(temp);
    }
    show_real(polynomial);
    cout << "导数为：" << polynomial.derivative() << '\n';
}
void show15() //求值
{
    Poly polynomial;
    double x;
    {
        char temp[101];
        cout << "请输入多项式：";
        cin.getline(temp, 100);
        polynomial.init(temp);
        cout << "请输入x的值：";
        cin >> x;
    }
    show_real(polynomial);
    printf("当x的值为%f时，多项式的值为： %f", x, polynomial.value(x));
}

岚花落_
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++的可视化计算器
Barcelona_Lu的博客
08-03 1万+
学生党的一个课程设计，希望可以对有些人有些帮助，第一次发，不好的话请多多原谅 c++： 一．题目要求：   设计一个可视化的计算器，可以执行+，-，*，/，.，%，（）等操作。要求使用API来编写程序。（我的计算器输入的时候是以#号开始）。   二．需求分析：   1.问题描述： ①——用api来编写一个可视化的计算器程序，首先我们要用界面来实现它，所以我们要设计一个
C++计算器（可视化）
09-26
C++计算器，可视化编程。希望对你有所帮助。
[源码和文档分享]基于C++的多项式计算器
12-03 129
一、 实验环境 1.1 编程语言和开发工具 语言采用ANSI C++（C++11） 开发工具：vim，g++，git，Visual Stdio（用于生成exe文件） 1.2 编码规范 编码规范中所有没有涉及到的内容，参见googlestyle C++ 类名 类名采用开头大写的方式命名 变量 局部变量采用小驼峰法命名 ...
c++可视化计算器
08-04
课程设计c++计算器，比较简单的计算器，第一次开发只实现了基本功能
可视化计算器
12-25
自己编用c++的一个mfc计算器，比win自带的要好些，供专业实习用，欢迎大家下载使用，也欢迎大家程序提出宝贵意见，共同进步
C语言-一元稀疏多项式计算器
03-27
本项目“C语言-一元稀疏多项式计算器”专注于利用C语言来处理一元稀疏多项式运算，包括加法、减法、乘法和除法。在本文中，我们将详细探讨这一主题，以及如何用C语言实现这些功能。 一元稀疏多项式是指多项式中大...
c一元稀疏多项式计算器-课程设计实验报告.pdf
10-30
本次课程设计的目标是开发一个一元稀疏多项式计算器，该计算器能够进行多项式的输入、输出、加法、减法等基本运算，并具有用户友好的界面。这个项目旨在强化学生的实践能力，特别是在数据结构领域的应用。通过完成这...
一元稀疏多项式计算器
03-23
在本文中，我们将深入探讨“一元稀疏多项式计算器”的设计与实现，这是一个基于MFC（Microsoft Foundation Classes）的可视化应用程序。MFC是微软提供的一套C++库，用于简化Windows应用程序的开发，它提供了丰富的...
数据结构：一元稀疏多项式计算器（含图形界面）
10-08
设计一个C++模板类Polynomial，其中T给出了系数的类型。类Polynomial应该带有一个私有成员degree，它是多项式的阶数。当然，它还可能包含其他的私有成员。...采用适当的多项式测试一元稀疏多项式简单计算器的基本功能。
一元稀疏多项式计算器 数据结构课程设计
06-11
在本课程设计中，主题是“一元稀疏多项式计算器”，这是一项针对数据结构学习者的重要实践任务。数据结构是计算机科学中的基石，它研究如何有效地存储和组织数据，以便于高效地进行访问和操作。在这个项目中，我们将...
C++ 多项式计算器
05-30
C++ 多项式计算器 控制台项目
C++可视化四则运算计算器
11-15
可视化，会四则运算；对付C++课程设计足够了，最好是一个人用。
C++计算器可视化.rar
03-20
基于MFC界面的计算器，可以实现简单的加减乘除，代码简单易懂，下载可以直接运行
多项式计算器c++实现，Qt界面
05-30
（1）问题描述 设计一个简单的一元稀疏多项式计算器。 （2）基本要求 一个简单的一元稀疏多项式计算器具体功能如下： 按照指数升序次序，输入并建立多项式A和B； 输出多项式，输出形式为整数序列 ； 多项式A和B相加，建立并计算出多项式A＋B的值； 多项式A和B相减，建立并计算出多项式A－B的值； 按指数升序次序输出计算结果； 指数为int，可正可负，系数为double； 计算器仿真界面。 （3）数据结构及算法分析 可用带表头结点的单链表存储多项式，多项式的项数存放在头结点中。
C++中，用mfc做的可视化的计算器程序
09-09
用mfc做的可视化的计算器程序。可以进行四则运算，幂，指数，对数，三角，统计等运算。
计算器（可视化，报错）MFC C++
qq_44596449的博客
06-27 619
#include "stdafx.h" #include "MFCApplication1.h" #include "MFCApplication1Dlg.h" #include "afxdialogex.h" #include <string> #include<stack> #ifdef _DEBUG #define new DEBUG_NEW #endif using...
【c++】基于Qt实现一个可视化的简易计算器
最新发布
m0_62370558的博客
09-29 789
视频展示无标题视频——使用Clipchamp制作。
[源码和文档分享]基于C++实现的多项式计算器系统
qq_38474647的博客
12-15 157
1 实验目的 本实验面向 C++语言的初学者。 主要让实验者熟悉面向对象的编程思想以及类的使用。 2 实验环境 本实验可基于Visual Studio 或Eclipse 或Dev C++平台开发，参考主流的编码规范，如Google C++Style Guide（中文版） 2.1 编程语言和开发工具 ...
多项式计算器-中缀变后缀并求值-C++版
wcxdell的专栏
09-17 693
闲着没事写了一个计算器回忆一下，支持加减乘除，括号，10以上的运算和负数。 不过没做错误判定，你的式子要是对的才行。。。 -19+(-3-(-11))*13+4/2 我的例子 因为最近用STL比较多，为了写起来方便，所以多了很多类型转换的地方，会影响一些效率，但是这个还是以实现功能为主吧。 class Solution { public: int calcul
一元稀疏多项式计算器与最小生成树设计详解
本篇文档是关于《数据结构》课程设计的一个实验报告，主要涉及两个关键部分：一元稀疏多项式计算器的设计和最小生成树问题的求解。报告由蒋林达等同学共同完成，指导教师为刘小晶。 一、问题描述： 1. 一元稀疏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

岚花落_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值