欢迎访问 Lu程序设计

循序渐进Lu 例程

目 录

1 概述 2 预备知识 3 最简单的例子 4 检测运行错误 5 检测返回值的类型 6 使Lu能输出信息 | 7 注册常量和二级函数 8 编写使用表达式的二级函数 9 基于系统内置对象创建扩展数据类型 10 创建自定义数据类型 11 结语

1 概述 [返回页首]

如果你喜欢Lu，想用Lu编程而又无从下手，那么本文的例子将会对你有所帮助。

Lu核心库的头文件是lu32.h，有C++和C两个版本，本文仅提供了C++版本的例子。

本文所有的例子均在VS C++ 2008环境下编译通过，编译时请将活动解决方案配置为“Release”。这都是些完整的例子，复制下来直接编译运行即可。为了减少代码，这些例子都是控制台应用程序，简单地加以改写，将它应用到实用的Windows程序中去是不难的。

本文没有穷尽Lu的所有用法和功能，而且还很不够。如果你还有什么不明白的，可以直接与我联系：forcal@sina.com 。

2 预备知识 [返回页首]

使用Lu的预备知识并不多，只要你会加载和卸载动态库（dll），而且懂一点多线程编程的知识就可以了。

2.1 加载和卸载Lu

（1）隐式调用

使用Lu核心库的导入库文件lu32.lib。这种方法比较方便，本文的例子大多是隐式调用例子。

（2）显示调用

应用程序可调用LoadLibrary直接加载Lu32.dll。

HANDLE hLu; //动态库模块句柄；
hLu=LoadLibrary(L"Lu32.dll"); //加载动态库Lu32.dll；

加载Lu32.dll成功后，需调用函数GetProcAddress获取Lu输出函数的地址。例如：

luInitLu pInitLu; //luInitLu 在头文件Lu32.h中定义，为初始化Lu的函数指针；
pInitLu=(luInitLu) GetProcAddress(hLu,"InitLu");

该函数获得了初始化Lu的函数地址，保存在指针pInitLu中。

当程序不再需要访问Lu32.dll时，应调用函数FreeLibrary将其卸载。

FreeLibrary(hLu); //释放动态库Lu32.dll；

2.2 在多线程中使用Lu

Lu可以用在单线程程序中，但不能及时退出漫长的计算过程或无限循环。没人愿意使用一个经常失去响应的程序。

为了安全地使用Lu，应用程序至少有两个线程，一个用于Lu计算，另一个用于监视Lu运行。

为了简单，本文的例子都是单线程的。多线程是一个更高级的概念，本文作为使用Lu的引玉之砖，没有提供这方面的例子。

3 最简单的例子 [返回页首]

只用到了Lu的四个输出函数：初始化 Lu的函数 InitLu，释放 Lu 的函数 FreeLu，编译表达式的函数LuCom和计算表达式的函数LuCal。

（1）隐式调用

仅需要以下支持文件（以后不再说明）：

1）头文件lu32.h。
2）导入库lu32.lib。
3）核心库lu32.dll。

    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "lu32.h"				//Lu头文件

    #pragma comment( lib, "lu32.lib" )

    using namespace std;

    void main(void)
    {
    	void *hFor;			//表达式句柄
    	luINT nPara;			//存放表达式的自变量个数
    	LuData *pPara;			//存放输入自变量的数组指针
    	LuData Val;			//存放表达式的值
    	luINT ErrBegin,ErrEnd;		//表达式编译出错的初始位置和结束位置
    	int ErrCode;			//错误代码
    	wchar_t ForStr[]=L"f(x,y)=x+y";	//字符串表达式
    	int i;

    	if(!InitLu()) return;		//初始化Lu

    	ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);	//编译表达式
    	if(ErrCode)
    	{
    		cout<<"表达式有错误！错误代码："<<ErrCode<<endl;
    	}
    	else
    	{
    		for(i=0;i<=nPara;i++)	//表达式自变量赋值，均赋值为1
    		{
    			pPara[i].BType=luStaData_int64; pPara[i].VType=luStaData_int64; pPara[i].x=1;
    		}
    		Val=LuCal(hFor,pPara);	//计算表达式的值
    		cout<<Val.x<<endl;
    	}
    	FreeLu();				//释放Lu
    }

运行结果：

2
请按任意键继续. . .

（2）显示调用

这个例子有三个函数：加载并初始化Lu的函数 theInitLu，释放Lu的函数theFree Lu和主函数main，主函数编译并计算了一个表达式的值。前两个函数的内容完全可以并入主函数，但分开写显得更清晰一些。

    #include <windows.h>
    #include <cmath>
    #include <iostream>
    #include <iomanip>
    #include "Lu32.h"

    using namespace std;

    HINSTANCE hLu=NULL;	//动态库Lu32.dll的句柄

    //动态库输出函数;
    luInitLu pInitLu;
    luFreeLu pFreeLu;
    luLuCom pLuCom;
    luLuCal pLuCal;

    bool theInitLu(void)	//初始化Lu
    {
    	hLu=LoadLibrary(L"Lu32.dll");	//加载动态库Lu32.dll
    	if(!hLu)
    	{
    		cout<<"找不到Lu32.dll！请将该库放到WINDOWS的搜索路径内！";
    		return false;
    	}

    	//以下几个语句获取Lu32.dll中所调用函数的地址
    	pInitLu=(luInitLu) GetProcAddress(hLu,"InitLu");
    	pFreeLu=(luFreeLu) GetProcAddress(hLu,"FreeLu");
    	pLuCom=(luLuCom) GetProcAddress(hLu,"LuCom");
    	pLuCal=(luLuCal) GetProcAddress(hLu,"LuCal");

    	if(!pInitLu||!pFreeLu||!pLuCom||!pLuCal)
    	{
    		cout<<"无效的动态库函数！"<<endl;
    		FreeLibrary(hLu);		//释放动态库Lu32.dll
    		hLu=NULL;
    		return false;
    	}

    	pInitLu();	//初始化Lu32.dll

    	return true;
    }

    void theFreeLu(void)	//释放Lu
    {
    	pFreeLu();	//释放Lu申请的空间
    	FreeLibrary(hLu);	//释放动态库
    }

    void main(void)
    {
    	void *hFor;    //表达式句柄
    	luINT nPara;   //存放表达式的自变量个数
    	LuData *pPara; //存放输入自变量的数组指针
    	LuData Val;    //存放表达式的值
    	luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
    	int ErrCode;   //错误代码
    	wchar_t ForStr[]=L"f(x,y)=x+y"; //字符串表达式
    	int i;

    	if(!theInitLu()) return; //初始化Lu

    	ErrCode=pLuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
    	if(ErrCode)
    	{
    		cout<<"表达式有错误！错误代码："<<ErrCode<<endl;
    	}
    	else
    	{
    		for(i=0;i<=nPara;i++) //表达式自变量赋值，均赋值为1
    		{
    			pPara[i].BType=luStaData_int64; pPara[i].VType=luStaData_int64; pPara[i].x=1;
    		}
    		Val=pLuCal(hFor,pPara); //计算表达式的值
    		cout<<Val.x<<endl;
    	}
    	theFreeLu();   //释放Lu
    }

运行结果：

2
请按任意键继续. . .

习题：

（1）更换不同的字符串表达式ForStr，重新编译运行程序，观察计算结果。

4 检测运行错误 [返回页首]

Lu在遇到运行错误时，就会停止计算而退出。在这个例子中，我们将添加运行错误检测功能。为此，只需要增加Lu的一个输出函数GetRunErr就可以了。

本例子是上一个例子的继续，新添加的部分用红色标记。

    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "lu32.h"				//Lu头文件

    #pragma comment( lib, "lu32.lib" )

    using namespace std;

    void main(void)
    {
    	void *hFor;			//表达式句柄
    	luINT nPara;			//存放表达式的自变量个数
    	LuData *pPara;			//存放输入自变量的数组指针
    	LuData Val;			//存放表达式的值
    	luINT ErrBegin,ErrEnd;		//表达式编译出错的初始位置和结束位置
    	int ErrCode;			//错误代码
    	wchar_t ForStr[]=L"f()=f()";	//字符串表达式，无穷递归调用引起堆栈溢出
    	int i;
    	int ErrType;			//运行错误类型
    	wchar_t *FunName;			//出错函数名
    	void *ForHandle;			//运行出错的表达式句柄

    	if(!InitLu()) return;		//初始化Lu

    	wcout.imbue(locale("chs"));		//设置输出的locale为中文

    	GetRunErr(ErrType,FunName,ErrCode,ForHandle);	//设置运行错误为无错状态
    	ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);	//编译表达式
    	if(ErrCode)
    	{
    		cout<<"表达式有错误！错误代码："<<ErrCode<<endl;
    	}
    	else
    	{
    		for(i=0;i<=nPara;i++)	//表达式自变量赋值，均赋值为1
    		{
    			pPara[i].BType=luStaData_int64; pPara[i].VType=luStaData_int64; pPara[i].x=1;
    		}
    		Val=LuCal(hFor,pPara);	//计算表达式的值
    		GetRunErr(ErrType,FunName,ErrCode,ForHandle);	//检查运行错误
    		if(ErrType)
    		{
    			wcout<<L"出现运行错误！错误类型："<<ErrType<<L" 出错函数名："<<FunName<<L" 错误代码："<<ErrCode<<endl;
    		}
    		else
    		{
    			wcout<<L"返回值："<<Val.x<<L" 基本类型："<<Val.BType<<L" 扩展类型："<<Val.VType<<endl;
    		}
    	}
    	FreeLu();				//释放Lu
    }

运行结果：

出现运行错误！错误类型：1 出错函数名：Lu::StackOverFlow 错误代码：1
请按任意键继续. . .

习题：

（1）更换不同的字符串表达式ForStr，重新编译运行程序，观察计算结果。

5 检测返回值的类型 [返回页首]

在这个例子中，我们将检测返回值的类型并输出不同结果。

本例子是上一个例子的继续，新添加的部分用红色标记。

    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "lu32.h"				//Lu头文件

    #pragma comment( lib, "lu32.lib" )

    using namespace std;

    void main(void)
    {
    	void *hFor;			//表达式句柄
    	luINT nPara;			//存放表达式的自变量个数
    	LuData *pPara;			//存放输入自变量的数组指针
    	LuData Val;			//存放表达式的值
    	luINT ErrBegin,ErrEnd;		//表达式编译出错的初始位置和结束位置
    	int ErrCode;			//错误代码
    	wchar_t ForStr[]=L"2-3i";		//字符串表达式
    	int i;
    	int ErrType;			//运行错误类型
    	wchar_t *FunName;			//出错函数名
    	void *ForHandle;			//运行出错的表达式句柄
    	wchar_t *pStr;

    	if(!InitLu()) return;		//初始化Lu

    	wcout.imbue(locale("chs"));		//设置输出的locale为中文

    	GetRunErr(ErrType,FunName,ErrCode,ForHandle);	//设置运行错误为无错状态
    	ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);	//编译表达式
    	if(ErrCode)
    	{
    		cout<<"表达式有错误！错误代码："<<ErrCode<<endl;
    	}
    	else
    	{
    		for(i=0;i<=nPara;i++)	//表达式自变量赋值，均赋值为1
    		{
    			pPara[i].BType=luStaData_int64; pPara[i].VType=luStaData_int64; pPara[i].x=1;
    		}
    		Val=LuCal(hFor,pPara);	//计算表达式的值
    		GetRunErr(ErrType,FunName,ErrCode,ForHandle);	//检查运行错误
    		if(ErrType)
    		{
    			wcout<<L"出现运行错误！错误类型："<<ErrType<<L" 出错函数名："<<FunName<<L" 错误代码："<<ErrCode<<endl;
    		}
    		else
    		{
    			wcout<<L"返回值基本类型："<<Val.BType<<L" 扩展类型："<<Val.VType<<endl;
    			switch(Val.BType)
    			{
    			case luStaData_nil:
    				wcout<<L"nil"<<endl;
    				break;
    			case luStaData_int64:
    				wcout<<Val.x<<endl;
    				break;
    			case luStaData_double:
    				wcout<<*(double *)&(Val.x)<<endl;
    				break;
    			case luStaData_complex:
    				wcout<<L"复数 实部："<<*(double *)&(Val.x)<<L" 虚部："<<*(double *)&(Val.y)<<endl;
    				break;
    			case luStaData_logical:
    				if(Val.x)
    					wcout<<L"true"<<endl;
    				else
    					wcout<<L"false"<<endl;
    				break;
    			case luStaData_string:
    			case luDynData_string:
    				pStr=GetStr(&Val,NULL,i);
    				if(pStr) wcout<<pStr<<endl;
    				break;
    			default:
    				wcout<<L"不可识别的类型！"<<endl;
    			}
    		}
    	}
    	FreeLu();				//释放Lu
    }

结果：

返回值基本类型：4 扩展类型：4
复数 实部：2 虚部：-3
请按任意键继续. . .

习题：

（1）更换字符串表达式ForStr的内容为"\"abc\"+\"123\""，重新编译运行程序，观察计算结果。[Lu不允许两个静态字符串相加]

（2）更换字符串表达式ForStr的内容为"new[string,\"abc\"]+\"123\""，重新编译运行程序，观察计算结果。

（3）更换字符串表达式ForStr的内容为"1>2"，重新编译运行程序，观察计算结果。

6 使Lu能输出信息 [返回页首]

Lu核心库的函数o以及许多注册到Lu的二级函数都将返回一些信息，为此，需要注册一个luMessage类型的函数到Lu（ 用 luPubKey_User 类型的4字节串"\0\0\0\0"键标识）。

    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "lu32.h"

    #pragma comment( lib, "lu32.lib" )

    using namespace std;

    void _stdcall LuMessage(wchar_t *pch) //输出动态库信息，该函数注册到Lu，由Lu二级函数调用
    {
    	wcout<<pch;
    }
    void main(void)
    {
    	void *hFor;		//表达式句柄
    	luINT nPara;		//存放表达式的自变量个数
    	LuData *pPara;		//存放输入自变量的数组指针
    	luINT ErrBegin,ErrEnd;	//表达式编译出错的初始位置和结束位置
    	int ErrCode;		//错误代码
    	void *v;
    	wchar_t ForStr[]=L"o{\"o函数返回的信息：\",22,\" \",22.,\" \",2-3i,\" \",1$2$3,\" \",2>3}";//字符串表达式

    	if(!InitLu()) return;	//初始化Lu
    	InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息

    	wcout.imbue(locale("chs"));	//设置输出的locale为中文

    	ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
    	if(ErrCode)
    	{
    		wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
    	}
    	else
    	{
    		LuCal(hFor,pPara);	//计算表达式的值
    	}
    	FreeLu();			//释放Lu
    }

结果：

> o函数返回的信息：22 22. {(2.)$(-3.)} {(1.)$(2.)$(3.)} false请按任意键继续. . .

7 注册常量和二级函数 [返回页首]

在这个例子中，我们将往Lu中注册常量和二级函数。

使用Lu的输出函数SetConst可以往Lu中添加常量，本例中只添加了一个实型常量PI。

使用Lu的输出函数SetFunction可以往Lu中添加二级函数，本例中只添加了一个二级函数add。

本例子是上一个例子的继续，新添加的部分用红色标记。

    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "lu32.h"

    #pragma comment( lib, "lu32.lib" )

    using namespace std;

    void _stdcall LuMessage(wchar_t *pch) //输出动态库信息，该函数注册到Lu，由Lu二级函数调用
    {
    	wcout<<pch;
    }
    //二级函数定义
    LuData _stdcall Fun2_add(luINT mm,LuData *xx,void *vFor)	//计算两个数的和，仅支持整数和实数加
    {
    	LuData a;

    	if(xx->VType==luStaData_int64 && (xx+1)->VType==luStaData_int64)
    	{
    		a.BType=luStaData_int64; a.VType=luStaData_int64;
    		a.x=xx->x+(xx+1)->x;
    	}
    	else if(xx->VType==luStaData_double && (xx+1)->VType==luStaData_double)
    	{
    		a.BType=luStaData_double; a.VType=luStaData_double;
    		*(double *)&(a.x)=*(double *)&(xx->x)+(*(double *)&((xx+1)->x));
    	}
    	else
    	{
    		a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    	}
    	return a;
    }

    void main(void)
    {
    	void *hFor;		//表达式句柄
    	luINT nPara;		//存放表达式的自变量个数
    	LuData *pPara;		//存放输入自变量的数组指针
    	luINT ErrBegin,ErrEnd;	//表达式编译出错的初始位置和结束位置
    	int ErrCode;		//错误代码
    	void *v;
    	wchar_t ForStr[]=L"o{\"2+3=\",add[2,3],\"  2.0+3.0=\",add[2.0,3.0],\"  2.0+3=\",add[2.0,3],\"  PI=\",PI}";//字符串表达式
    	LuData Val;

    	if(!InitLu()) return;	//初始化Lu
    	InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息

    	Val.BType=luStaData_double; Val.VType=luStaData_double; *(double *)&(Val.x)=3.1416;	//定义实数常量
    	SetConst(L"PI",&Val);		//设置实型常量
    	SetFunction(L"add",Fun2_add,1);	//设置二级函数

    	wcout.imbue(locale("chs"));	//设置输出的locale为中文

    	ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
    	if(ErrCode)
    	{
    		wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
    	}
    	else
    	{
    		LuCal(hFor,pPara);	//计算表达式的值
    	}
    	FreeLu();			//释放Lu
    }

结果：

> 2+3=5 2.0+3.0=5. 2.0+3=nil PI=3.1415999999999999请按任意键继续. . .

习题：

（1）在本例的基础上再添加一个实型常量_E=2.718，更换字符串表达式ForStr的内容为"_E"，重新编译运行程序，观察计算结果。

（2）在本例的基础上再添加一个二级函数 PrintStr，该函数已在下面给出 ，该函数使用了Lu的输出函数 GetStr 以获得字符串，并使用函数SearchKey以获得 输出信息函数（就是我们注册的函数 LuMessage）的句柄。记着更换字符串表达式ForStr的内容为"PrintStr(\"hello Lu!\")"，观察运行效果。

    LuData _stdcall PrintStr(luINT mm,LuData *xx,void *vFor)	//输出字符串
    {
    	luMessage pMessage;
    	wchar_t *pStr;
    	luVOID i=0;

    	pMessage=(luMessage)SearchKey((char *)&i,sizeof(luVOID),luPubKey_User);
    	if(pMessage)
    	{
    		pStr=GetStr(xx,vFor,i);
    		if(pStr) pMessage(pStr);
    	}
    	return *xx;
    }

（3）在本例的基础上再添加一个自定义的二级函数并检查运行效果。

8 编写使用表达式的二级函数 [返回页首]

本例注册了两个二级函数，函数ExeStrFor接受字符串形式的函数名并调用该函数，函数ExeHFor接受表达式句柄并调用该函数。

本例还将演示如何使用函数SetRunErr返回运行错误，以提供给用户更多的出错诊断信息。

    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "lu32.h"

    #pragma comment( lib, "lu32.lib" )

    using namespace std;

    void _stdcall LuMessage(wchar_t *pch) //输出动态库信息，该函数注册到Lu，由Lu二级函数调用
    {
    	wcout<<pch;
    }
    //二级函数定义
    LuData _stdcall ExeStrFor(luINT mm,LuData *xx,void *vFor)	//通过字符串形式的函数名调用一个函数
    {
    	LuData a,*vPara;
    	static wchar_t ErrName[]=L"ExeStrFor";
    	wchar_t *pStr;
    	luINT nPara;
    	luVOID nModule;
    	void *hFor;

    	a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    	if(mm<0)	//至少需要1个参数
    	{
    		SetRunErr(1,ErrName,1,0,vFor);
    		return a;
    	}
    	pStr=GetStr(xx,vFor,nModule);
    	if(!pStr)	//非法字符串参数
    	{
    		SetRunErr(1,ErrName,2,0,vFor);
    		return a;
    	}
    	if(GetFor(pStr,1,vFor,nModule,hFor,vPara,nPara))
    	{
    		if(nPara!=mm-1)	//调用表达式时参数不匹配
    		{
    			SetRunErr(1,ErrName,3,0,vFor);
    			return a;
    		}
    		return LuCal(hFor,xx+1);
    	}
    	else	//找不到表达式
    	{
    		SetRunErr(1,ErrName,4,0,vFor);
    		return a;
    	}
    }
    LuData _stdcall ExeHFor(luINT mm,LuData *xx,void *vFor)	//通过表达式句柄调用一个函数
    {
    	LuData a,*vPara;
    	static wchar_t ErrName[]=L"ExeHFor";
    	luINT nPara;
    	luVOID nModule;
    	void *hFor;

    	a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    	if(mm<0)	//至少需要1个参数
    	{
    		SetRunErr(1,ErrName,1,0,vFor);
    		return a;
    	}
    	if(xx->BType!=luStaData_forhandle)	//不是一个表达式句柄参数
    	{
    		SetRunErr(1,ErrName,2,0,vFor);
    		return a;
    	}
    	if(GetFor(NULL,1,(void *)*(luVOID *)&(xx->x),nModule,hFor,vPara,nPara))
    	{
    		if(nPara!=mm-1)	//调用表达式时参数不匹配
    		{
    			SetRunErr(1,ErrName,3,0,vFor);
    			return a;
    		}
    		return LuCal(hFor,xx+1);
    	}
    	else	//找不到表达式
    	{
    		SetRunErr(1,ErrName,4,0,vFor);
    		return a;
    	}
    }
    void main(void)
    {
    	void *hFor;		//表达式句柄
    	luINT nPara;		//存放表达式的自变量个数
    	LuData *pPara;		//存放输入自变量的数组指针
    	luINT ErrBegin,ErrEnd;	//表达式编译出错的初始位置和结束位置
    	int ErrCode1,ErrCode2;	//错误代码
    	void *v;
    	int ErrType;		//运行错误类型
    	wchar_t *FunName;		//出错函数名
    	void *ForHandle;		//运行出错的表达式句柄
    	wchar_t ForStr[]=L"f(x,y)=x+y";//字符串表达式
    	wchar_t MainStr[]=L"o{ExeHFor[@f,2,3],\"\r\n\"}";//字符串表达式

    	if(!InitLu()) return;	//初始化Lu

    	InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息

    	SetFunction(L"ExeStrFor",ExeStrFor,-2);	//设置二级函数
    	SetFunction(L"ExeHFor",ExeHFor,-2);		//设置二级函数

    	wcout.imbue(locale("chs"));	//设置输出的locale为中文

    	ErrCode1=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);	//编译表达式
    	ErrCode2=LuCom(MainStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);	//编译表达式
    	if(ErrCode1 || ErrCode2)
    	{
    		wcout<<L"表达式有错误！错误代码："<<ErrCode1<<L"  "<<ErrCode2<<endl;
    	}
    	else
    	{
    		LuCal(hFor,pPara);	//计算表达式的值
    		GetRunErr(ErrType,FunName,ErrCode1,ForHandle);	//检查运行错误
    		if(ErrType)
    		{
    			wcout<<L"出现运行错误！错误类型："<<ErrType<<L" 出错函数名："<<FunName<<L" 错误代码："<<ErrCode1<<endl;
    		}
    	}
    	FreeLu();			//释放Lu
    }

结果：

>     5
>     请按任意键继续. . .

习题：

（1）将 MainStr 修改如下，重新编译运行程序，观察计算结果。

>     wchar_t MainStr[]=L"o{ExeStrFor[\"f\",2,3],\"\r\n\"}";//字符串表达式

（2）将 MainStr 修改如下，重新编译运行程序，观察计算结果。

>     wchar_t MainStr[]=L"o{ExeStrFor[\"f\",2],\"\r\n\"}";//字符串表达式

9 基于系统内置对象创建扩展数据类型 [返回页首]

本例中，我们将基于系统内置实数数组创建矩阵（matrix）类型，即：基本类型为luDynData_realarray（标识实数数组），扩展类型为matrix（标识矩阵）。为了简单，我们仅处理二维实数数组即矩阵类型。

基本要点：

（1）为扩展类型matrix编写运算符重载函数OpMatrix。

（2）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。

（3）为扩展类型matrix编写其他操作函数（本例未提供）。

（4）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。

    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "lu32.h"

    #pragma comment( lib, "lu32.lib" )

    using namespace std;

    luKEY Matrix=-1000;	//标识矩阵类型，最终的Matrix由LockKey决定

    void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
    {
    	wcout<<pch;
    }
    void _stdcall DelMatrix(void *me)	//用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
    {
    }
    LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)	//运算符重载函数，用于LockKey函数
    {
    	LuData a;
    	luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
    	luVOID i,j,k,m,n,u,v;
    	double *pa,*pb,*pc;
    	luMessage pMessage;
    	wchar_t wchNum[32];
    	char chNum[32];

    	a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    	switch(theOperator)
    	{
    	case 2:	//重载运算符*
    		pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    		pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
    		if(!pRealArray1 || !pRealArray2) break;	//对象句柄无效，不是实数数组
    		if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;	//不是二维实数数组（矩阵）
    		if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;	//维数不匹配
    		pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);	//创建矩阵对象
    		if(!pRealArray3) break;
    		pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];	//设置矩阵维数大小
    		pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
    		m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
    		for(i=0; i<m; i++)	//矩阵乘
    		{
    			for(j=0; j<k; j++)
    			{
    				u=i*k+j; pc[u]=0.0;
    				for (v=0; v<n; v++)
    				{
    					pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
    				}
    			}
    		}
    		FunReObj(hFor);	//告诉Lu，返回一个动态对象
    		a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
    		break;
    	case 25:	//重载运算符.*
    		pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    		pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
    		if(!pRealArray1 || !pRealArray2) break;	//对象句柄无效，不是实数数组
    		if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;	//不是二维实数数组（矩阵）
    		if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;	//维数不相同
    		pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);	//创建矩阵对象
    		if(!pRealArray3) break;
    		pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];	//设置矩阵维数大小
    		for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
    		FunReObj(hFor);	//告诉Lu，返回一个动态对象
    		a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
    		break;
    	case 46:	//重载函数new
    		a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);	//直接调用基本类型luDynData_realarray的new函数
    		if(a.VType==luDynData_realarray) a.VType=Matrix;	//设置扩展类型为自定义的Matrix类型
    		break;
    	case 49:	//重载函数o
    		pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
    		if(!pMessage) break;
    		pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    		if(!pRealArray1) break;	//对象句柄无效，不是实数数组
    		if(pRealArray1->DimLen!=2) break;	//不是二维实数数组（矩阵）
    		pa=pRealArray1->Array;
    		m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
    		for(i=0; i<m; i++)	//输出矩阵
    		{
    			pMessage(L"\r\n"); k+=2;
    			for(j=0; j<n; j++)
    			{
    				_gcvt_s(chNum,pa[i*n+j],16);
    				for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
    				wchNum[u]='\0';
    				pMessage(wchNum); pMessage(L"  "); k+=2;
    			}
    		}
    		pMessage(L"\r\n"); k+=2;
    		a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;	//按函数o的要求，返回输出的字符总数
    		break;
    	default:
    		break;
    	}
    	return a;
    }

    void main(void)
    {
    	void *hFor;		//表达式句柄
    	luINT nPara;		//存放表达式的自变量个数
    	LuData *pPara;		//存放输入自变量的数组指针
    	luINT ErrBegin,ErrEnd;	//表达式编译出错的初始位置和结束位置
    	int ErrCode;		//错误代码
    	void *v;
    	wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2,data: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘
    	//wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3,data: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘
    	LuData Val;

    	if(!InitLu()) return;	//初始化Lu

    	while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}	//锁定一个键，用于存储矩阵扩展类型

    	Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;	//定义整数常量
    	SetConst(L"matrix",&Val);	//设置整数常量

    	InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息

    	wcout.imbue(locale("chs"));	//设置输出的locale为中文

    	ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
    	if(ErrCode)
    	{
    		wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
    	}
    	else
    	{
    		LuCal(hFor,pPara);	//计算表达式的值
    	}

    	LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
    	FreeLu();			//释放Lu
    }

习题：

（1）自定义矩阵的加、减、左除、右除、点左除等运算，自编测试字符串代码，重新编译运行程序，观察计算结果。

（2）小矩阵乘效率测试。编译运行以下Lu字符串代码：

> main(:a,b,c,d,t,i)=
> a=new[matrix,2,2,data:1.,2.,2.,1.],
> b=new[matrix,2,2,data:2.,1.,1.,2.],
> c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
> t=clock(),
> d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
> o{d, "time=",[clock()-t]/1000.," seconds.\r\n"}

C/C++中的字符串定义为：

    	wchar_t ForStr[]=L"main(:a,b,c,d,t,i)= a=new[matrix,2,2,data:1.1,2.,2.,1.], b=new[matrix,2,2,data:2.,1.,1.,2.], c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.], t=clock(), d=a*b, i=0, while{i<1000000, d=d*c*b, i++}, o{d, \"time=\",[clock()-t]/1000.,\" seconds.\r\n\"}";//字符串表达式

结果：

> 4. 5.
> 5. 4.
> time=0.875 seconds.
> 请按任意键继续. . .

Matlab 2009a 代码：

> a=[1.,2.;2.,1.];
> b=[2.,1.;1.,2.];
> c=[2/3.,-1/3.;-1/3.,2/3.];
> tic,
> d=a*b;
> for i=1:1000000
> d=d*c*b;
> end
> d,
> toc

结果：

>     d =

>          4     5
>          5     4

>     Elapsed time is 2.903034 seconds.

本例矩阵乘效率测试，Lu的速度超过了Matlab，主要在于Lu有更高的动态对象管理效率。

10 创建自定义数据类型 [返回页首]

本例中，我们将自定义矩阵（matrix）类型，基本类型和扩展类型均为matrix（标识矩阵）。

基本要点：

（1）编写生成矩阵（matrix）的函数NewMatrix和销毁矩阵的函数DelMatrix。

（2）为自定义类型matrix编写运算符重载函数OpMatrix。

（3）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。

（4）为自定义类型matrix编写其他操作函数（本例未提供）。

（5）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。

    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include "lu32.h"

    #pragma comment( lib, "lu32.lib" )

    using namespace std;

    //自定义矩阵
    class myMatrix
    {
    public:
    	double *Array;	//数据缓冲区
    	luVOID ArrayLen;	//数据缓冲区长度
    	luVOID Dim[2];	//矩阵维数
    	myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
    	~myMatrix()
    	{
    		if(Array) delete[] Array;
    	}
    };

    luKEY Matrix=-1000;	//标识矩阵类型，最终的Matrix由LockKey决定

    void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
    {
    	wcout<<pch;
    }
    void _stdcall DelMatrix(void *me)	//用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
    {
    	delete (myMatrix *)me;
    }
    myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)	//生成一个myMatrix对象
    {
    	myMatrix *pMatrix;
    	luVOID k;
    	double *pa;
    	char keyname[sizeof(luVOID)];
    	void *NowKey;

    	k=m*n;
    	pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
    	if(pMatrix)
    	{
    		if(pMatrix->ArrayLen!=k)	//重置矩阵的大小
    		{
    			pa=new double[k];
    			if(!pa)
    			{
    				DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);	//将矩阵对象放回缓冲区
    				return NULL;
    			}
    			delete[] pMatrix->Array;
    			pMatrix->Array=pa;
    		}
    	}
    	else
    	{
    		pMatrix=new myMatrix;	//创建矩阵对象
    		if(!pMatrix) return NULL;
    		pMatrix->Array=new double[k];
    		if(!pMatrix->Array)
    		{
    			delete pMatrix;
    			return NULL;
    		}
    		if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))	//将矩阵对象注册到Lu
    		{
    			delete pMatrix;
    			return NULL;
    		}
    	}
    	pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
    	return pMatrix;
    }
    LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)	//运算符重载函数，用于LockKey函数
    {
    	LuData a;
    	myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
    	luVOID i,j,k,m,n,u,v;
    	double *pa,*pb,*pc;
    	luMessage pMessage;
    	wchar_t wchNum[32];
    	char chNum[32];

    	a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    	switch(theOperator)
    	{
    	case 2:	//重载运算符*
    		pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
    		pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
    		if(!pMatrix1 || !pMatrix2) break;	//对象句柄无效，不是矩阵
    		if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;	//维数不匹配
    		pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);	//生成新矩阵
    		if(!pMatrix3) break;
    		pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
    		m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
    		for(i=0; i<m; i++)	//矩阵乘
    		{
    			for(j=0; j<k; j++)
    			{
    				u=i*k+j; pc[u]=0.0;
    				for (v=0; v<n; v++)
    				{
    					pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
    				}
    			}
    		}
    		FunReObj(hFor);	//告诉Lu，返回一个动态对象
    		a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
    		break;
    	case 25:	//重载运算符.*
    		pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
    		pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
    		if(!pMatrix1 || !pMatrix2) break;	//对象句柄无效，不是矩阵
    		if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;	//维数不相同
    		pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);	//生成新矩阵
    		if(!pMatrix3) break;
    		for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];	//矩阵点乘
    		FunReObj(hFor);	//告诉Lu，返回一个动态对象
    		a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
    		break;
    	case 46:	//重载函数new
    		if(mm<2) break;
    		if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
    		pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
    		if(!pMatrix3) break;
    		for(j=0,i=3;i<=mm;i++,j++)	//赋初值
    		{
    			if(j>=pMatrix3->ArrayLen) break;
    			if((xx+i)->BType!=luStaData_double) break;	//只接受实数参数
    			pMatrix3->Array[j]=*(double *)&((xx+i)->x);
    		}
    		FunReObj(hFor);	//告诉Lu，返回一个动态对象
    		a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
    		break;
    	case 49:	//重载函数o
    		pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
    		if(!pMessage) break;
    		pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
    		if(!pMatrix1) break;	//对象句柄无效，不是矩阵
    		pa=pMatrix1->Array;
    		m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
    		for(i=0; i<m; i++)	//输出矩阵
    		{
    			pMessage(L"\r\n"); k+=2;
    			for(j=0; j<n; j++)
    			{
    				_gcvt_s(chNum,pa[i*n+j],16);
    				for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
    				wchNum[u]='\0';
    				pMessage(wchNum); pMessage(L"  "); k+=2;
    			}
    		}
    		pMessage(L"\r\n"); k+=2;
    		a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;	//按函数o的要求，返回输出的字符总数
    		break;
    	default:
    		break;
    	}
    	return a;
    }

    void main(void)
    {
    	void *hFor;		//表达式句柄
    	luINT nPara;		//存放表达式的自变量个数
    	LuData *pPara;		//存放输入自变量的数组指针
    	luINT ErrBegin,ErrEnd;	//表达式编译出错的初始位置和结束位置
    	int ErrCode;		//错误代码
    	void *v;
    	wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘
    	//wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘
    	LuData Val;

    	if(!InitLu()) return;	//初始化Lu

    	while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}	//锁定一个键，用于存储矩阵扩展类型

    	Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;	//定义整数常量
    	SetConst(L"matrix",&Val);	//设置整数常量

    	InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息

    	wcout.imbue(locale("chs"));	//设置输出的locale为中文

    	ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
    	if(ErrCode)
    	{
    		wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
    	}
    	else
    	{
    		LuCal(hFor,pPara);	//计算表达式的值
    	}
    	LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
    	FreeLu();			//释放Lu
    }

习题：

（1）自定义矩阵的加、减、左除、右除、点左除等运算，自编测试字符串代码，重新编译运行程序，观察计算结果。

（2）小矩阵乘效率测试。编译运行以下Lu字符串代码：

> main(:a,b,c,d,t,i)=
> a=new[matrix,2,2: 1.,2.,2.,1.],
> b=new[matrix,2,2: 2.,1.,1.,2.],
> c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
> t=clock(),
> d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
> o{d, "time=",[clock()-t]/1000.," seconds.\r\n"}

C/C++中的字符串定义为：

    	wchar_t ForStr[]=L"main(:a,b,c,d,t,i)= a=new[matrix,2,2: 1.,2.,2.,1.], b=new[matrix,2,2: 2.,1.,1.,2.], c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.], t=clock(), d=a*b, i=0, while{i<1000000, d=d*c*b, i++}, o{d, \"time=\",[clock()-t]/1000.,\" seconds.\r\n\"}";//字符串表达式

结果：

> 4. 5.
> 5. 4.
> time=0.797 seconds.
> 请按任意键继续. . .

Matlab 2009a 代码：

> a=[1.,2.;2.,1.];
> b=[2.,1.;1.,2.];
> c=[2/3.,-1/3.;-1/3.,2/3.];
> tic,
> d=a*b;
> for i=1:1000000
> d=d*c*b;
> end
> d,
> toc

结果：

>     d =

>          4     5
>          5     4

>     Elapsed time is 2.903034 seconds.

本例矩阵乘效率测试，Lu的速度超过了Matlab，主要在于Lu有更高的动态对象管理效率。

与上例相比较可以知道，自定义数据类型和系统内置类型有近乎相同的效率。

11 结语 [返回页首]

虽然还可以添加更多的例子，但是作为一个入门教程，就先写到这儿了。

如果你对本文有什么意见或建议，请给我发E-mail：forcal@sina.com 。

版权所有© Lu程序设计 2011-2013，保留所有权利
E-mail: forcal@sina.com QQ：630715621
最近更新: 2013年09月11日