纯C语言用Windows api写画函数图像

最新推荐文章于 2024-08-11 07:47:28 发布
最新推荐文章于 2024-08-11 07:47:28 发布
阅读量2k 收藏 14
点赞数 2
分类专栏： Windows API编程 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49547348/article/details/121222275
版权

数学绘图 函数解析 四则运算 语法检查 C语言
关键词由CSDN通过智能技术生成

！！！如有转载 请注明出处！！！

主要功能介绍：
1、输入函数的解析式，可以在窗口中画出解析式的函数图像。
2、解析式只能以x为自变量。
3、解析式目前只能写数字、括号、加减乘除四则运算(±*/)，不能写乘方、开方、各种函数（三角函数、对数等等）。
4、输入解析式时，程序禁用中文输入法，也不能输入中文括号。.
5、输入解析式语法错误时，程序弹出对话框并告知哪里有错误，允许重新输入。
6、输入解析式的窗口在任务栏不显示。
7、输入解析式的窗口一旦打开，主窗口就不响应任何操作，直到输入解析式的窗口关闭。关闭以后，主窗口重画所有函数图像和x、y轴。
8、x、y轴为黑色，图像红色。

环境：
Windows10 64位，MinGW-POSIX-64位。

注：
1、若为32位系统，据说需要将SetWindowLongPtr换为SetWindowLong，里面参数GWLP_WNDPROC需要换为GWL_WNDPROC（我也没试过，所以不能那么肯定。大家可以自己试一试）

2、如果编译不通过，在makefile.bat中编译可执行文件的一行手动链接pthread库。

3、如果报错不支持WinMain函数入口，可以百度下载msys64（大概就是这么一个东西）来支持win32应用程序，至于如何安装百度都有，这里不赘述。

截图：






代码如下：

//libtranslateexpression.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <windows.h>
#include <math.h>

#define SGR_MAX_EXPR 1024

#define CHECKFUNC_NO_ERROR				0x00
#define CHECKFUNC_FOUND_TIMEADDBR		0x01
#define CHECKFUNC_FOUND_TIMESUBBR		0x02
#define CHECKFUNC_FOUND_DIVADDBR		0x03
#define CHECKFUNC_FOUND_DIVSUBBR		0x04
#define CHECKFUNC_BRACKET_ERROR			0x05
#define CHECKFUNC_NONUMBERAFTERSIGN		0x06
#define CHECKFUNC_NONUMBERBEFORESIGN	0x07
#define CHECKFUNC_DECIMALPOINT_ERROR	0x08
#define CHECKFUNC_VARIBLEHASNOSIGN		0x09

BOOL CheckFuncExpr(const char* expr)
{
	if(strstr(expr,"*+(")!=NULL)	return CHECKFUNC_FOUND_TIMEADDBR;
    if(strstr(expr,"*-(")!=NULL)	return CHECKFUNC_FOUND_TIMESUBBR;
    if(strstr(expr,"/+(")!=NULL)	return CHECKFUNC_FOUND_DIVADDBR;
    if(strstr(expr,"/-(")!=NULL)	return CHECKFUNC_FOUND_DIVSUBBR;
    
	int i=0,bracket=0;
    for(;expr[i]!='\0';i++)
    {
		if(expr[i]=='(')	bracket++;
        if(expr[i]==')')	bracket--;
        if(bracket<0)		return CHECKFUNC_BRACKET_ERROR;
        if(expr[i]=='+' || expr[i]=='-')
        {
			if(expr[i+1]!='(' && expr[i+1]>'9' && expr[i+1]<'0' && expr[i+1]!='x')	return CHECKFUNC_NONUMBERAFTERSIGN;
        }
        if(expr[i]=='*' || expr[i]=='/')
        {
			if(i==0)																return CHECKFUNC_NONUMBERBEFORESIGN;
			if(expr[i+1]!='(' && expr[i+1]>'9' && expr[i+1]<'0' && expr[i+1]!='x')	return CHECKFUNC_NONUMBERAFTERSIGN;
            if(expr[i-1]!='(' && expr[i-1]>'9' && expr[i-1]<'0' && expr[i-1]!='x')	return CHECKFUNC_NONUMBERBEFORESIGN;
        }
        if(expr[i]=='.')
        {
			if(expr[i+1]<'0' && expr[i+1]>'9') return CHECKFUNC_DECIMALPOINT_ERROR;
            if(expr[i-1]<'0' && expr[i-1]>'9') return CHECKFUNC_DECIMALPOINT_ERROR;
        }
        if(expr[i]=='x')
        {
			if((expr[i+1]>'0' && expr[i+1]<'9') || expr[i+1]=='.') return CHECKFUNC_VARIBLEHASNOSIGN;
            if(i!=0)
				if((expr[i-1]>'0' && expr[i-1]<'9') || expr[i-1]=='.') return CHECKFUNC_VARIBLEHASNOSIGN;
        }
    }
    if(bracket!=0)
		return CHECKFUNC_BRACKET_ERROR;
    return CHECKFUNC_NO_ERROR;
}

BOOL CheckNum(double x)
{
	switch(fpclassify(x))
    {
	case FP_ZERO:return TRUE;
    case FP_NORMAL:return TRUE;
    default:return FALSE;
    }
}

void ReplaceAddSign(char* expr,char*out)
{
	memset(out,0,sizeof(char)*SGR_MAX_EXPR);
	char *k=expr;
	char *p=out;

	if(*expr!='+' && *expr!='-')
    {
		*p='+';p++;
        *p=*k;
    }

    while(*k!='\0')
    {
		if(*k!='+' && *k!='-')
        {
			*p=*k;p++;k++;
        }
        else
        {
			if(*(k-1)!='+' && *(k-1)!='-')*p=*k;
            if(*k=='-' && (*(k-1)=='+' || *(k-1)=='-'))*p=(*p=='+')?'-':'+';
            if(*(k+1)!='+' && *(k+1)!='-')p++;
            k++;
        }
    }
    p=out;
    while(*p!='\0')
    {
		if(*p>='9' && *p<='0' && *p!='.' && *(p+1)=='+')
			memmove(p+1,p+2,strlen(p+2)+1);
        p++;
    }
}

double GetResult_addsub(char* expr)
{
	double a=0,b=0;
    char* p=expr;
    if(*p=='+' ||*p=='-')p++;
    sscanf(p,"%lf",&a);
    if(*(p-1)=='-')a=-a;
    while(1)
    {
        while(*p!='+' && *p!='-')
        {
			p++;
            if(*p==0)break;
        }
        if(sscanf(++p,"%lf",&b)==0)break;
        switch(*(p-1))
        {
			case '+':a+=b;break;
			case '-':a-=b;break;
        }
    }
    return a;
}

double GetResult_timediv(char* expr)
{
	double a=0,b=0;
    char* p=expr;
    sscanf(p,"%lf",&a);
    while(1)
    {
        while(*p!='/' && *p!='*')
        {
			p++;
            if(*p==0)break;
        }
        if(sscanf(++p,"%lf",&b)<=0)break;
        switch(*(p-1))
        {
			case '*':a*=b;break;
			case '/':a/=b;break;
            case '-':
				switch(*(p-2))
                {
					case '*':a*=-b;break;
                    case '/':a/=-b;break;
                }
                break;
        }
    }
    return a;
}

void gettimedivexpr(const char*expr,char*out)
{
	for(int i=0;expr[i]!='\0';i++)
    {
		if(((expr[i]>='0' && expr[i]<='9') || expr[i]=='.' || expr[i]=='*' || expr[i]=='/') || (expr[i]=='-' && (expr[i-1]=='*' || expr[i-1]=='/')))out[i]=expr[i];
        else	break;
    }
}

double nonebracket_TranslateExpression(char*expr)
{
	char RepAS[SGR_MAX_EXPR]={0};
    ReplaceAddSign(expr,RepAS);

    char*p=RepAS;
	char**p_sep;
    
    double a=0;
    double res[SGR_MAX_EXPR/2]={0.0};
    int n=0,i;
    
    char**sep=(char**)malloc(SGR_MAX_EXPR/2*sizeof(char*));

	for(i=0;i<SGR_MAX_EXPR/2;i++)
    {
		sep[i]=(char*)malloc(SGR_MAX_EXPR*sizeof(char));
        memset(sep[i],0,sizeof(char)*SGR_MAX_EXPR);
    }
    for(p_sep=sep;*p!='\0';n++,p_sep++)
    {
		sscanf(p++,"%c",*p_sep);
        gettimedivexpr(p,(*p_sep)+1);
        p+=strlen((*p_sep)+1);
	}
	for(p_sep=sep;**p_sep!='\0';p_sep++)res[p_sep-sep]=GetResult_timediv(*p_sep+1);
	for(p_sep=sep;**p_sep!='\0';p_sep++)res[p_sep-sep]*=(**p_sep=='+')?(1):(-1);
    for(p_sep=sep;**p_sep!='\0';p_sep++)a+=res[p_sep-sep]; 
	for(i=0;i<SGR_MAX_EXPR/2;i++)
    {
		free(sep[i]);
        sep[i]=NULL;
    }
    free(sep);sep=NULL;
    return a;
}

UINT getbracketstep(char*expr)
{
	UINT bracket=0;
    UINT mostbracket=0;
    UINT i=0;
	for(;expr[i]!='\0';i++)
    {
		switch(expr[i])
        {
        case '(':
			bracket++;
            if(mostbracket<bracket)
				mostbracket=bracket;
            break;
        case ')':
			bracket--;
            break;
        }
    }
	return mostbracket;
}

void exprbracketpos(char*expr,UINT bracketstep,char**out)
{
	UINT i=0;
    UINT bracket=0;
    UINT p=0;
    for(;expr[i]!='\0';i++)
    {
		switch(expr[i])
        {
        case '(':
			bracket++;
            break;
        case ')':
			bracket--;
            if(bracket==bracketstep-1)	p++;
            break;
        }
        if(bracket==bracketstep)
			out[p][strlen(out[p])]=expr[i];
    }
}

double TranslateExpression(char*expr)
{
	UINT mostbracket=getbracketstep(expr);
    if(mostbracket==0)
		return nonebracket_TranslateExpression(expr);
    int bracket=0;
    int i=0;
    char decomp[SGR_MAX_EXPR]={'\0'};
    char laststr[SGR_MAX_EXPR]={'\0'};
    for(;expr[i]!='\0';i++)
    {
		if(expr[i]==')')
        {
			bracket--;
            if(bracket==0)
            {
                sprintf(laststr+strlen(laststr),"%lf",TranslateExpression(decomp));
                memset(decomp,0,strlen(decomp));
                continue;
            }
        }
		if(bracket>=1)decomp[strlen(decomp)]=expr[i];
		if(expr[i]=='(')
        {
			bracket++;
        }
        if(bracket==0)laststr[strlen(laststr)]=expr[i];
    }
    return nonebracket_TranslateExpression(laststr);
}

double GetIndependent(char*func,char indep,double volue)
{
	char expr[SGR_MAX_EXPR]={'\0'};
	for(int i=0;func[i]!='\0';i++)
    {
		if(func[i]==indep)
			sprintf(expr+strlen(expr),"%lf",volue);
        else
			expr[strlen(expr)]=func[i];
    }
    return TranslateExpression(expr);
}

这是一个库的代码，具体就是表达式求值功能。

还有def文件（libtranslateexpression.def）：

LIBRARY libtranslateexpression.dll
EXPORTS
	CheckFuncExpr		@1
	CheckNum			@2	
	TranslateExpression	@3
	GetIndependent		@4

接下来是exe文件的代码：

#include <windows.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <math.h>

#define HMENU_PAINT_FUNC 1

#define HMENU_func_TEXTFX 2
#define HMENU_func_EDITFX 3
#define HMENU_func_BUTTONOKAY 4
#define HMENU_func_BUTTONCANCEL 5

#define SGR_MAX_EXPR 1024

#define CHECKFUNC_NO_ERROR				0x00
#define CHECKFUNC_FOUND_TIMEADDBR		0x01
#define CHECKFUNC_FOUND_TIMESUBBR		0x02
#define CHECKFUNC_FOUND_DIVADDBR		0x03
#define CHECKFUNC_FOUND_DIVSUBBR		0x04
#define CHECKFUNC_BRACKET_ERROR			0x05
#define CHECKFUNC_NONUMBERAFTERSIGN		0x06
#define CHECKFUNC_NONUMBERBEFORESIGN	0x07
#define CHECKFUNC_DECIMALPOINT_ERROR	0x08
#define CHECKFUNC_VARIBLEHASNOSIGN		0x09

BOOL CheckFuncExpr(const char*expr);
BOOL CheckNum(double x);
double GetIndependent(char*func,char indep,double volue);

char functions[64][SGR_MAX_EXPR]={{0}};
int funcnum=0;

void paintfunc(int enlarge,HWND hwnd)
{
	static PAINTSTRUCT ps;
    static HPEN hpen;
    static RECT rect;
	static HDC hdc;
    hdc=BeginPaint(hwnd,&ps);
    hpen=CreatePen(PS_SOLID,1,RGB(255,0,0));
    GetClientRect(hwnd,&rect);
	SelectObject(hdc,hpen);
    
    static int i;
    static int j;
    static BOOL paint;
    static double y;

    for(j=0;j<funcnum;j++)
    {
        for(i=-rect.right/2;i<rect.right/2;i++)
		{
			y=GetIndependent(functions[j],'x',(double)(i)/enlarge);
			if(CheckNum(y))
            {
				MoveToEx(hdc,rect.right/2+i,rect.bottom/2-y*enlarge,NULL);
				break;
            }
        }
        
		for(paint=TRUE;i<(rect.right-rect.left)/2;i++)
		{
			y=GetIndependent(functions[j],'x',(double)(i)/enlarge);
			if(CheckNum(y))
			{
				if(paint==TRUE)
					LineTo(hdc,rect.right/2+i,rect.bottom/2-y*enlarge);
				else
                {
					MoveToEx(hdc,rect.right/2+i,rect.bottom/2-y*enlarge,NULL);
                    paint=TRUE;
				}
            }
            else	paint=FALSE;
        }
	}
    
    for(i=0;i<rect.right;i++)	SetPixel(hdc,i,rect.bottom/2,RGB(0,0,0));
	for(i=0;i<rect.bottom;i++)	SetPixel(hdc,rect.right/2,i,RGB(0,0,0));
    
    DeleteObject(hpen);
    EndPaint(hwnd,&ps);
}

HINSTANCE hInst;

BOOL NEWWINDOWEXISTS=FALSE;
BOOL MAINWINDOW_RESP=TRUE;
RECT MAINWINDOW_RECT;

pthread_t FuncInput_pth;

HWND FuncInput_hwnd;
HWND Main_hwnd;

WNDPROC func_hEDITfx_old_WndProc;

LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);
LRESULT CALLBACK func_WndProc(HWND,UINT,WPARAM,LPARAM);
LRESULT CALLBACK func_hEDITfx_WndProc(HWND,UINT,WPARAM,LPARAM);

BOOL CreateFuncInputWindow(HWND hwnd)
{
	static TCHAR szAppName[]=TEXT("MathPaint_FuncInput");
    MSG msg;
	WNDCLASS wndclass;
    
    wndclass.lpfnWndProc=func_WndProc;
    wndclass.cbClsExtra=0;
    wndclass.cbWndExtra=0;
    wndclass.hInstance=hInst;
    wndclass.hIcon=LoadIcon(NULL,IDI_APPLICATION);
    wndclass.hCursor=LoadCursor(NULL,IDC_ARROW);
    wndclass.hbrBackground=(HBRUSH)CreateSolidBrush(RGB(240,240,240));
    wndclass.lpszMenuName=NULL;
    wndclass.lpszClassName=szAppName;
    
    RegisterClass(&wndclass);
    
    hwnd=CreateWindow(szAppName,TEXT("绘制新函数..."),WS_BORDER|WS_CAPTION|WS_VISIBLE|WS_SYSMENU|WS_POPUP|WS_CHILD,
						(MAINWINDOW_RECT.left+MAINWINDOW_RECT.right)/2-200,(MAINWINDOW_RECT.top+MAINWINDOW_RECT.bottom)/2-100,400,200,Main_hwnd,NULL,hInst,NULL);
    ShowWindow(hwnd,SW_SHOW);
	UpdateWindow(hwnd);
    while(GetMessage(&msg,hwnd,0,0)>0)
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
        Sleep(50);
	}
	return msg.wParam;
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR szCmdLine,int iCmdShow) 
{ 
    ShowWindow(GetForegroundWindow(),SW_HIDE);
    DestroyWindow(GetForegroundWindow());
    
	static TCHAR szAppName[]=TEXT("MathPaint");
	HWND hwnd;
	MSG msg;
	WNDCLASS wndclass;
    
    hInst=hInstance;

	wndclass.style=CS_HREDRAW|CS_VREDRAW;
	wndclass.lpfnWndProc=WndProc; 
	wndclass.cbClsExtra=0; 
	wndclass.cbWndExtra=0;
	wndclass.hInstance=hInstance;
	wndclass.hIcon=LoadIcon(NULL,IDI_APPLICATION); 
	wndclass.hCursor=LoadCursor(NULL,IDC_ARROW); 
	wndclass.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH); 
	wndclass.lpszMenuName=NULL;
	wndclass.lpszClassName=szAppName; 
	RegisterClass(&wndclass);
    
	Main_hwnd=hwnd=CreateWindow(szAppName,TEXT("MathPaint"),WS_MAXIMIZE|WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,NULL,NULL,hInstance,NULL);
	ShowWindow(hwnd,SW_SHOW);
	UpdateWindow(hwnd);

	while(GetMessage(&msg,hwnd,0,0)>0)
	{
		if(MAINWINDOW_RESP==FALSE && NEWWINDOWEXISTS==FALSE)
        {
			NEWWINDOWEXISTS=TRUE;
			pthread_create(&FuncInput_pth,NULL,(void*)CreateFuncInputWindow,FuncInput_hwnd);
        }
		TranslateMessage(&msg);
		DispatchMessage(&msg);
        Sleep(50);
	}
	return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	static HMENU hmenu_paint;
    static HMENU hmenu_paint_func;
    
    if(MAINWINDOW_RESP==TRUE)
	{
		EnableMenuItem(hmenu_paint,0,MF_BYPOSITION|MF_ENABLED);
		switch(message) 
		{ 
		case WM_CREATE: 
			GetWindowRect(hwnd,&MAINWINDOW_RECT);
            hmenu_paint=CreateMenu();
            hmenu_paint_func=CreateMenu();
            AppendMenu(hmenu_paint_func,MF_ENABLED|MF_STRING,HMENU_PAINT_FUNC,TEXT("绘制新函数..."));
            AppendMenu(hmenu_paint,MF_ENABLED|MF_STRING|MF_POPUP,(UINT_PTR)hmenu_paint_func,TEXT("作图(p)"));
            SetMenu(hwnd,hmenu_paint);
            return 0;
        case WM_COMMAND:
			switch(LOWORD(wParam))
            {
			case HMENU_PAINT_FUNC:
				MAINWINDOW_RESP=FALSE;
                EnableMenuItem(hmenu_paint,0,MF_BYPOSITION|MF_GRAYED);
				return 0;
            }
            return 0;
        case WM_PAINT:
			GetWindowRect(hwnd,&MAINWINDOW_RECT);
            break;
		}
    }
    
    else
    {
		switch(message)
        {
        case WM_CLOSE:
			return 0;
        case WM_MOVE:
			MoveWindow(hwnd,MAINWINDOW_RECT.left,MAINWINDOW_RECT.top,MAINWINDOW_RECT.right-MAINWINDOW_RECT.left,MAINWINDOW_RECT.bottom-MAINWINDOW_RECT.top,TRUE);
            return 0;
        }
    }
    switch(message)
    {
	case WM_PAINT:
		paintfunc(50,hwnd);
        break;
    }
    return DefWindowProc(hwnd,message,wParam,lParam);
}

LRESULT CALLBACK func_hEDITfx_WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	ImmAssociateContext(hwnd,NULL);
	switch(message)
    {
    case WM_CHAR:
		switch(wParam)
        {
		case '(':break;
        case ')':break;
        case 'x':break;
        case '+':break;
        case '-':break;
        case '*':break;
        case '/':break;
        case 8:break;
        default:
			if(wParam>='0' && wParam<='9')	break;
            else return 0;
        }
        break;
    case WM_PASTE:
		return 0;
    }
	return func_hEDITfx_old_WndProc(hwnd,message,wParam,lParam);
}

LRESULT CALLBACK func_WndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	static RECT rect;
    static HWND hTEXTfx;
    static HWND hEDITfx;
    static HWND hBUTTONokay;
    static HWND hBUTTONcancel;
    
	static HFONT hfont;
    
    static int width;
    static int height;
    
    static char FuncExpr[SGR_MAX_EXPR];
	
	switch(message)
    {
    case WM_CREATE:
		GetClientRect(hwnd,&rect);
        
        width=rect.right-rect.left;
        height=rect.bottom-rect.top;
        
        hfont=CreateFont(-15,-7.5,0,0,400,FALSE,FALSE,FALSE,DEFAULT_CHARSET,OUT_CHARACTER_PRECIS,CLIP_CHARACTER_PRECIS,DEFAULT_QUALITY,FF_DONTCARE,TEXT("微软雅黑"));
        
		hTEXTfx=CreateWindow(TEXT("static"),TEXT("y="),WS_CHILD|WS_VISIBLE|SS_CENTERIMAGE|SS_LEFT,width/16,height/8,width/4,height/8,hwnd,(HMENU)HMENU_func_TEXTFX,hInst,NULL);
        hEDITfx=CreateWindow(TEXT("edit"),TEXT(""),WS_CHILD|WS_VISIBLE|WS_BORDER|ES_AUTOVSCROLL|ES_MULTILINE,width/16,height/4,width/2,height/2,hwnd,(HMENU)HMENU_func_EDITFX,hInst,NULL);
        
        hBUTTONcancel=CreateWindow(TEXT("button"),TEXT("取消"),WS_CHILD|WS_VISIBLE|WS_BORDER|BS_CENTER,width*11/16,height/8,width/4,height*3/10,hwnd,(HMENU)HMENU_func_BUTTONCANCEL,hInst,NULL);
        hBUTTONokay=CreateWindow(TEXT("button"),TEXT("确定"),WS_CHILD|WS_VISIBLE|WS_BORDER|BS_CENTER,width*11/16,height*23/40,width/4,height*3/10,hwnd,(HMENU)HMENU_func_BUTTONOKAY,hInst,NULL);

		SendMessage(hTEXTfx,WM_SETFONT,(WPARAM)hfont,(LPARAM)NULL);
        SendMessage(hEDITfx,WM_SETFONT,(WPARAM)hfont,(LPARAM)NULL);
		SendMessage(hBUTTONcancel,WM_SETFONT,(WPARAM)hfont,(LPARAM)NULL);
        SendMessage(hBUTTONokay,WM_SETFONT,(WPARAM)hfont,(LPARAM)NULL);
        
        func_hEDITfx_old_WndProc=(WNDPROC)SetWindowLongPtr(hEDITfx,GWLP_WNDPROC,(LONG)func_hEDITfx_WndProc);
        break;
    case WM_COMMAND:
		switch(LOWORD(wParam))
        {
		case HMENU_func_BUTTONCANCEL:
			DestroyWindow(hwnd);
            break;
        case HMENU_func_BUTTONOKAY:
			memset(FuncExpr,0,strlen(FuncExpr));
			GetWindowText(hEDITfx,FuncExpr,sizeof(FuncExpr));
            switch(CheckFuncExpr(FuncExpr))
            {
            case CHECKFUNC_FOUND_TIMEADDBR   :MessageBox(NULL,TEXT("乘号(*)后面不可以跟随加号(+)。"),TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
            case CHECKFUNC_FOUND_TIMESUBBR   :MessageBox(NULL,TEXT("乘号(*)后面不可以跟随减号(-)。"),TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
            case CHECKFUNC_FOUND_DIVADDBR    :MessageBox(NULL,TEXT("除号(/)后面不可以跟随加号(+)。"),TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
			case CHECKFUNC_FOUND_DIVSUBBR    :MessageBox(NULL,TEXT("除号(/)后面不可以跟随减号(-)。"),TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
            case CHECKFUNC_BRACKET_ERROR     :MessageBox(NULL,TEXT("括号错误")					    ,TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
            case CHECKFUNC_NONUMBERAFTERSIGN :MessageBox(NULL,TEXT("运算符后无数字")				,TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
            case CHECKFUNC_NONUMBERBEFORESIGN:MessageBox(NULL,TEXT("运算符前无数字")				,TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
            case CHECKFUNC_DECIMALPOINT_ERROR:MessageBox(NULL,TEXT("小数点错误")					,TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
            case CHECKFUNC_VARIBLEHASNOSIGN	 :MessageBox(NULL,TEXT("自变量不能与数字直接连接")	    ,TEXT("函数语法错误"),MB_OK|MB_ICONERROR);return 0;
            }
            if(strlen(FuncExpr)!=0)	sprintf(functions[funcnum++],"%s",FuncExpr);
			DestroyWindow(hwnd);
            break;
        }
        break;
    case WM_DESTROY:
		NEWWINDOWEXISTS=FALSE;
		MAINWINDOW_RESP=TRUE;
        PostQuitMessage(0);
        InvalidateRect(Main_hwnd,NULL,TRUE);
        break;
    }
	return DefWindowProc(hwnd,message,wParam,lParam);
}

makefile.bat：

gcc -c -O3 libtranslateexpression.c
dllwrap --def libtranslateexpression.def -o libtranslateexpression.dll libtranslateexpression.o --output-lib libtranslateexpression.a
gcc mathpaint.c -o mathpaint.exe -lgdi32 -limm32 libtranslateexpression.dll
pause

大约花了一周左右，现在忙于学业还要上网课，也就做到这个程度。
接下来方向是准备实现ln log sin cos tan cot sec csc arcsin arccos arctan arcsec arccsc sqrt abs 根号 乘方。

感谢阅读 希望大家看一看代码而不是仅仅复制。
如有转载 请注明出处。

//尚同学:-)
关注
专栏目录
Windows下的api 以及 C语言的一些api
u012138730的专栏
12-15 1870
RegisterClass宏 winuser.h #ifdef UNICODE #define RegisterClass RegisterClassW #else #define RegisterClass RegisterClassA #endif // !UNICODE https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-registerclassw 注册一个窗口类，在随后的CreateWi...
用C语言编程绘制函数的图像.pdf
09-19
用C语言编程绘制函数的图像.pdf
简单的用c语言画数学函数图像
akbarmain的博客
02-16 1万+
大家好 今天给大家分享画y=2sin(2x)函数图像的简单易用例子 首先需要搭建环境 需要装一个可以编译运行c/c++代码的IDE（集成开发环境）VS ,VC6.0等.我推荐VS2019 需要安装EasyX图形界面库，这个库很好用，适合初学者。 windows xp以及一行版本我用win8.1 编程思路 搭建图形界面窗口 在搭建的界面中绘制X轴，Y轴。 根据函数关系计算出函数值 根据函数值绘...
如何用C语言绘图？绘图技术详解
最新发布
极客代码
08-11 1862
C语言绘图技术是计算机图形学的基础，它通过操作系统的API直接与硬件交互，实现了高效的图形绘制。本文介绍了C语言在Windows和Linux平台下的绘图基础，包括基本的绘图操作和双缓冲技术，以及图形变换和颜色像素操作。这些技术为开发者提供了丰富的工具，使得C语言在游戏开发、图像处理等领域仍然保持着强大的生命力。在下一部分中，我们将进一步探讨C语言绘图的高级技术，包括硬件加速、3D绘图和动画效果等内容。这些技术将帮助读者更深入地理解C语言绘图的能力，并能够创造出更加丰富和动态的图形界面。
如何使用C语言绘制函数图像
热门推荐
ht_vIC的博客
12-17 3万+
如何用C语言画出函数图像 安装easyX https://easyx.cn/这是easyX的库，下载安装程序安装即可 绘制思想 绘制数学图形最简单的思想就是将各个点绘制出来就可以了。 代码 #include<stdio.h> #include<graphics.h> #include<conio.h> #include<stdlib.h> #define s 10 //这是一个比率，相当于我把图形放大10倍 int main() { initgrap
【续集】 C语言图形和函数图像的绘制【其他部分 第二章】
DuanXu-yzc
10-23 4679
图形输出是C语言初学者经常遇到的问题，实际上大多数简单的图形并不需要使用复杂的控制结构，所见即所得的方法更加简洁，不过对于复杂的图形或者函数图像，使用控制结构会更好。在使用控制结构输出图形时，要把握一个原则：只能逐行输出，因此，在输出一行时必须把这一行中所有需要输出的字符全部输出，所以，找到每行中各个位置需要输出的字符（或者说，各字符在每行中的位置）尤为关键！我们有两种方法来确定位置，其中第二种方法更通用简洁。在输出图形时，特别是函数图像，要充分利用对称、平移关系简化程序，另外，要注意调节屏幕的行宽比和适当
c语言 图片按钮winapi,一个简单的实现显示指定图片功能的WinAPI程序
weixin_40009207的博客
05-24 700
///////////////////一个简单的 WinAPI程序，///实现功能：///创建一个窗口，并在窗口上双击鼠标左键，以打开一个指定的图片文件，并在窗口上显示该图片。///////////////////#include // Windows SDK 要用到的#include // 打开文件的窗口要包含这个头文件//用到了 IPicture 接口，要包含下面两个 头文件#include#...
[纯C语言 + Win32 API]一步一步写个围棋程序之十：可以下棋了
09-01
在本教程中，我们将探索如何使用纯C语言和Win32 API来开发一个简单的围棋程序。这个项目的第十部分重点在于实现玩家能够在棋盘上下棋的功能。让我们深入了解一下这个过程涉及的关键知识点。 首先，纯C语言是编程的...
[纯C语言 + Win32 API]一步一步写个围棋程序之二十二：最终代码
09-26
4. **图形绘制**：使用Win32 API的GDI（Graphics Device Interface）函数来绘制棋盘网格和棋子图像。 5. **窗口管理**：创建窗口，响应窗口消息，如WM_PAINT消息用于更新屏幕显示，WM_COMMAND消息处理菜单和按钮的...
[纯C语言 + Win32 API]一步一步写个围棋程序之五：工具栏之一
08-27
在本篇中，我们将深入探讨如何使用纯C语言和Win32 API来构建一个围棋程序，特别是关于工具栏的第一部分。对于初学者来说，理解Windows应用程序的基本架构和控件的使用是至关重要的，而工具栏作为用户界面的重要组成...
[纯C语言 + Win32 API]一步一步写个围棋程序之二十一：保存图形棋谱
09-14
在本教程中，我们将深入探讨如何使用纯C语言和Win32 API来开发一个围棋程序，并专注于第二十一部分——保存图形棋谱的功能。这是一项重要的技术，它允许玩家记录和回顾游戏过程，对于学习和分享策略具有极大的价值。...
用C语言实现的画线代码（画任意曲线）
01-06
用C语言实现画任意曲线，在VC界面里输出所画的线
Win32纯API实现的简单画图程序
12-11
完美封装winmain接口，画直线、矩形、圆、多边形，并实现放大、缩小、移动、删除等编辑功能，并能保存、读取图形信息，画笔颜色和粗细也可以选择
windows 绘图函数
04-25
该文档描述了在windows开发中绘图的部分，主要是窗口的重绘，其中还描述了相关窗口的组成部分，如非客户去，窗口背景，窗口坐标系统等等
【其他部分 第二章 C语言图形和函数图像的绘制】
DuanXu-yzc
10-15 1万+
第二章 图形和函数图像的绘制 本章详细讨论如何使用C语言绘制出各种规则的图形和一些常见函数的图像。   一、    使用所见即所得的方法绘制 直接上代码： /* * 所见即所得的绘制方法 * 缺点：不灵活、不易修改 * 优点：直观、简单 */ #include int main ( void ) { // 绘制正方形 printf ( "\n" );
C语言 函数图形绘制系统
technologist_37的博客
07-06 3156
系统功能简述： 初等函数曲线图形的简易绘制：设屏幕显示文本是25行， 80列，可以用“+”和“——〉”号画坐标系，用“*”号画曲线上的点。用户给出初等函数，如cos（x），e^x,x^3-3x+1等，及x的取值范围，程序绘制出对应初等函数的曲线图。 功能要求： 1.从键盘上输入x的显示范围； 2.根据x的取值范围在屏幕上画出函数图形； 3.函数的选择可以由键盘输入得到。 #include <stdio.h> #include <stdlib.h> #include <ma
c语言如何画函数图形,c语言绘制函数曲线
weixin_34611130的博客
05-24 1816
该楼层疑似违规已被系统折叠隐藏此楼查看此楼我这种方法为什么图形只能显示一下就不见了，这是为什么？能不能用在双曲线上？？能的话改哪里？？#include#includefloat a,b,c,xmin,xmax,max; void menu(){printf("\n*****welcome*****\n");printf("\n 1.input coefficie...
C语言画Sinc函数图像
amen_yanwang的博客
12-08 672
C语言，Sinc函数图像
【C++第三天】Win API下得简单绘图
輪廻箱庭
08-15 639
自己看C++已经第三天了, 虽然没什么明显的成果, 但是还是让自己小小的兴奋了一下, 从最开始的仿照书编写绘制基本图形, 跟踪鼠标事件, 设置Timer到BitMap简单遮罩. 到刚刚自己尝试着使用Timer清屏, 及一个Sin函数动态绘制. 代码如下. 虽然很初级, 但还是让自己小小的兴奋了一下。 代码如下. void MyPaint(HWND hWnd, HDC hdc){ RECT
C语言实现Windows API入门与实例解析教程
10. 调试与优化：分享一些有效的调试技巧，以及如何使用Windows API函数进行性能优化。 由于提供的文件信息中“【压缩包子文件的文件名称列表】”字段只有"222"这一条目，这意味着文件列表没有给出，因此无法提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值