C/C++对Lu系统内置动态对象进行运算符重载

1 说明


    要演示本文的例子，你必须下载Lu32脚本系统。本文的例子需要lu32.dll、lu32.lib、C格式的头文件lu32.h，相信你会找到并正确使用这几个文件。


    用C/C++编译器创建一个控制台应用程序，复制本文的例子代码直接编译运行即可。


2 关于运算符重载


    在本教程系列的开始，介绍了Lu脚本的基本数据结构（详细参考Lu编程指南），即：


[cpp] view plaincopy
struct LuData{    //Lu基本数据结构。  
    luIFOR x;     //luIFOR被定义为64位整数__int64，用于存放数据。对于动态数据类型，对象指针约定保存在x的前4个字节中。  
    luIFOR y;     //存放数据。  
    luIFOR z;     //存放数据。  
    luKEY  VType; //luKEY被定义为32位整数__int32。扩展数据类型，决定重载函数，从而决定了对数据的操作方式。  
    luKEY  BType; //基本数据类型，决定了Lu数据的结构。  
};  


    基本数据类型BType决定了实际的数据结构，而扩展数据类型VType决定了重载函数。若要对某数据类型VType进行运算符重载，需要用函数LockKey对VType加锁，该函数定义如下：


int _stdcall LockKey(luKEY VType,void (_stdcall *DeleteKey)(void *),luOperator OpLock);


    VType：被锁定的键的类型。VType>luPubKey_User（公有键、普通键）或者 VType     DeleteKey：删除键值的函数指针，用于标识要加锁的键。该函数由用户定义，但由Lu调用。若DeleteKey=NULL，表示解锁指定的键。
    OpLock：luOperator类型的函数指针，用于对象（用指针标识）的运算符重载，该参数不可为NULL。解锁和加锁所用的OpLock函数必须相同。参考[注1]。


    如果加锁或解锁成功，该函数返回0，否则返回非0值。


    [注1]：运算符重载函数luOperator函数格式如下（与Lu二级函数相比，仅多了一个参数theOperator）：


[cpp] view plaincopy
//m指出数组Para的参数个数（也即操作数的个数，0表示1个，1表示2个，以此类推）。  
//hFor为调用该函数的表达式句柄（与二级函数中的表达式句柄相同）。  
//theOperator指出运算符的类型或操作类型：+、-、*、/、^、... ...。  
LuData (_stdcall *luOperator)(luINT m,LuData *Para,void *hFor,int theOperator);  
  
LuData _stdcall OpLock(luINT m,LuData *Para,void *hFor,int theOperator)  
{  
    //... ...  
    switch(theOperator)  
    {  
    case 0:    //重载运算符+  
        //... ...  
    case 1:    //重载运算符-  
        //... ...  
    case 2:    //重载运算符*  
        //... ...  
    case 3:    //重载运算符%  
        //... ...  
    case 4:    //重载运算符/  
        //... ...  
    ... ...  
    }  
}  


    如果不打算给加锁的键提供运算符或函数重载功能，须使用函数SetRunErr向Lu报告运行错误。


    本文讨论C/C++对Lu系统内置动态对象进行运算符重载。本文的例子来自Lu系统扩展库LuSystem中的Lu表（有改动，有所简化），参考源代码lu1code.rar，实现对Lu系统内置动态对象lu的数据类型扩展luu（基本类型为 luDynData_lu，扩展类型为 key_luu）。


    动态对象lu是一个线性表（简称Lu表，可以保存任何数据，包括任意多个lu表），是Lu脚本的基本数据类型，参考C格式的头文件lu32.h，动态对象lu的结构定义如下：


//动态Lu表
typedef struct luLu
{
    LuData *Lu; //允许为NULL
    luVOID Len; //Lu数据缓冲区长度
} luLu;


    Lu表在Lu系统键树中的键值（即基本数据类型BType）为luDynData_lu，参考头文件lu32.h中的定义：


#define luDynData_lu -255 //动态Lu数据


3 代码


[cpp] view plaincopy
#include  
#include  
#include "lu32.h"  
  
#pragma comment( lib, "lu32.lib" )  
  
luKEY key_luu = luPoiKey_User-20;   //标识luu的私有键，将对其加锁  
  
void _stdcall Del_luu(void *me) //销毁luu的函数，但什么也不做，只为了配合运算符重载，加锁键使用  
{  
}  
  
void _stdcall LuMessage(wchar_t *pch) //输出动态库信息，该函数注册到Lu，由Lu二级函数调用  
{  
    wprintf(L"%s",pch);  
}  
  
//Lu脚本可调用的二级函数定义  
//生成一个luu对象，注册到Lu脚本系统  
LuData _stdcall lu_luu(luINT mm,LuData *xx,void *vFor)  
{  
    static wchar_t ErrName[]=L"luu";  
    luINT i;  
    luLu *pLu;  
    LuData a;  
  
    pLu=(luLu *)NewSysObj(luDynData_lu,mm+1,0);  
    if(!pLu)  
    {  
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;  
        return a;  
    }  
    for(i=0;i<=mm;i++) pLu->Lu[i]=xx[i];  
    a.BType=luDynData_lu; a.VType=key_luu; a.x=0; *(luVOID *)&(a.x)=(luVOID)pLu;  
    FunReObj(vFor);  
    return a;  
}  
  
//返回两个luu相加（或者一个luu加其他任意数据）的结果，通过运算符重载间接调用  
LuData _stdcall lu_addLuu(luINT mm,LuData *xx,void *vFor)  
{  
    static wchar_t ErrName[]=L"luu +";  
    luLu *pLu,*pLu0,*pLu1;  
    luVOID i,j;  
    LuData a;  
  
    a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;  
    pLu0=(luLu *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_lu);  
    pLu1=(luLu *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_lu);  
    if(pLu0 && pLu1 && xx->BType==luDynData_lu && (xx+1)->BType==luDynData_lu)  
    {  
        pLu=(luLu *)NewSysObj(luDynData_lu,pLu0->Len+pLu1->Len,0);  
        if(!pLu) return a;  
        for(i=0,j=0;iLen;i++,j++) pLu->Lu[j]=pLu0->Lu[i];  
        for(i=0;iLen;i++,j++) pLu->Lu[j]=pLu1->Lu[i];  
    }  
    else if(pLu0  && xx->BType==luDynData_lu)  
    {  
        pLu=(luLu *)NewSysObj(luDynData_lu,pLu0->Len+1,0);  
        if(!pLu) return a;  
        for(i=0,j=0;iLen;i++,j++) pLu->Lu[j]=pLu0->Lu[i];  
        pLu->Lu[j]=xx[1];  
    }  
    else if(pLu1 && (xx+1)->BType==luDynData_lu)  
    {  
        pLu=(luLu *)NewSysObj(luDynData_lu,pLu1->Len+1,0);  
        if(!pLu) return a;  
        for(i=0,j=1;iLen;i++,j++) pLu->Lu[j]=pLu1->Lu[i];  
        pLu->Lu[0]=xx[0];  
    }  
    else  
    {  
        return a;  
    }  
    a.BType=luDynData_lu; a.VType=key_luu; a.x=0; *(luVOID *)&(a.x)=(luVOID)pLu;  
    FunReObj(vFor);  
    return a;  
}  
  
//输出luu的信息，通过重载函数o间接调用  
LuData _stdcall lu_oLuu(luINT mm,LuData *xx,void *vFor)  
{  
    static wchar_t ErrName[]=L"luu o";  
    luLu *pLu;  
    luMessage pMessage;  
    luVOID k=0;  
    LuData a;  
  
    a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=0;  
    pMessage=(luMessage)SearchKey((char *)&k,sizeof(luVOID),luPubKey_User);  
    if(!pMessage) return a;  
    pLu=(luLu *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_lu);  
    if(!pLu)        //不可识别的lu对象  
    {  
        SetRunErr(1,ErrName,1,0,vFor); return a;  
    }  
    pMessage(L"luu{... ...} ");  
    a.x=13;  
    return a;  
}  
  
LuData _stdcall OpLock_luu(luINT m,LuData *Para,void *vFor,int theOperator) //luu的运算符重载函数  
{  
    LuData a;  
  
    switch(theOperator)  
    {  
    case 0: //重载运算符+  
        return lu_addLuu(m,Para,vFor);  
    case 44:    //重载函数len  
        Para->VType=luDynData_lu;  
        a=ExeOperator(m,Para,vFor,theOperator,luDynData_lu);    //直接调用基本类型luDynData_lu的len函数  
        Para->VType=key_luu;  
        return a;  
    case 46:    //重载函数new  
        a=ExeOperator(m,Para,vFor,theOperator,luDynData_lu);    //直接调用基本类型luDynData_lu的new函数  
        if(a.VType==luDynData_lu) a.VType=key_luu;      //设置扩展类型为自定义的key_luu类型  
        return a;  
    case 47:    //重载函数oset  
    case 48:    //重载函数oget  
        Para->VType=luDynData_lu;  
        a=ExeOperator(m,Para,vFor,theOperator,luDynData_lu);    //直接调用基本类型luDynData_lu的oset或oget函数  
        Para->VType=key_luu;  
        return a;  
    case 49:    //重载函数o  
        return lu_oLuu(m,Para,vFor);  
    default:  
        SetRunErr(1,L"luu 无法识别的运算符！",theOperator,0,vFor);  
        break;  
    }  
    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;        //错误代码  
    LuData Val;     //Lu基本数据类型  
    void *v=NULL;       //为了避免编译器报错，初始化为NULL  
    luVOID k=0;     //32位平台上luVOID被定义为__int32；64位平台上luVOID被定义为__int64；k必须赋值为0  
    wchar_t ForStr[]=L"main(:a,i)= a=luu[22, \"abc\",3.5], o[a], i=-1,while{++i   
    setlocale(LC_ALL, "chs");   //设置可以输出中文  
  
    if(!InitLu()) return;   //初始化Lu  
  
    InsertKey((char *)&k,sizeof(luVOID),luPubKey_User,LuMessage,NULL,NULL,1,v);//使Lu运行时可输出函数信息  
  
    Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=key_luu;    //定义整数常量luu，标识luu对象  
    SetConst(L"luu",&Val);  //设置常量  
  
    SetFunction(L"luu",lu_luu,-2);  //设置二级函数，参数-2表示有不确定的任意多个自变量  
  
    LockKey(key_luu,Del_luu,OpLock_luu);    //在Lu键树中加锁键，只能存储luu类型，但实际上什么也不存储，只为了配合运算符重载  
  
    ErrCode=LuCom(ForStr,0,0,0,&hFor,&nPara,&pPara,&ErrBegin,&ErrEnd);  //编译表达式  
    if(ErrCode)  
    {  
        printf("表达式有错误！错误代码： %d \n",ErrCode);  
    }  
    else  
    {  
        LuCal(hFor,pPara);  //计算表达式的值，hFor即编译得到的表达式句柄  
    }  
  
    LockKey(key_luu,NULL,OpLock_luu);   //在Lu键树中解锁键  
  
    FreeLu();           //释放Lu  
}  


运行结果：


luu{... ...} 22 abc 3.5


4 函数说明


    本例用到了Lu的10个输出函数：初始化Lu的函数InitLu，释放Lu的函数FreeLu，编译表达式的函数LuCom、计算表达式的函数LuCal、加锁键函数LockKey、注册C/C++函数的函数SetFunction、申请系统内置动态对象函数NewSysObj、插入键值的函数InsertKey、查找键值的函数SearchKey、按指定类型执行运算符重载函数ExeOperator。从这里查看这些函数的说明：Lu编程指南。


5 难点分析


    在对Lu系统内置动态对象进行运算符重载时，需要：（1）用LockKey加锁一个键（本例为key_luu），但不需要向Lu系统注册任何键值；（2）删除键值的函数（本例为Del_luu）定义为空函数；（3）定义运算符重载函数（本例为OpLock_luu）。


    值得一提的是，使用申请系统内置动态对象函数NewSysObj很方便，不仅高效，而且返回的对象已注册到了Lu键树中，不需要自己再进行注册。使用按指定类型执行运算符重载函数ExeOperator也很方便，免去了自己的编码之苦。


    （1）如果修改代码中的字符串表达式为（注意C/C++字符串中转义字符 \" 的使用，下同）：


main(:a,i)= a=new[luu,3 : 22, "abc",3.5], o[a], i=-1,while{++i

    可得到如下结果：


luu{... ...} 22 abc 3.5


    （2）如果修改代码中的字符串表达式为：


main(:a,i)= a=luu[22, "abc",3.5], a=55+a+"asd", o[a], i=-1,while{++i

    可得到如下结果：


luu{... ...} 55 22 abc 3.5 asd


6 其他


    你可能注意到了，我的联系方式就在下面，如有不明之处或有什么建议，可随时与我进行联系。