Lu系统扩展动态库LuSystem之类及对象

 Lu系统扩展动态库LuSystem之类及对象

 

    类（class）是一个具有数据成员和方法成员的自定义数据结构。类可以继承和派生，类的层次结构是一棵树。

    类对象（obj）是类的实例。

     sys::class{... ...}：创建类定义

    类定义格式如下：

class{#cMyClass: #cBase1, #cBase2, ...  //定义类cMyClass，继承自cBase1和cBase2, ...
private:                  //私有数据成员
  #pvMem1, #pvMem2, ...
public:                   //公有数据成员
  #plMem1, #plMem2, ...
method:                   //方法（函数成员）
  #__init__ : @init, #__del__ : @delme, #mFun1 ：@Fun1, #mFun2 ：@Fun2, ...
};

    类定义中，类名称、基类名称、成员及方法都是以#开头的标识符，不可重复。类名称在最前面，其次是基类名称；private、public及method的次序是任意的，且可多次定义；方法标识符后必须提供函数句柄。类成员的存储顺序与其定义顺序不一定相同。

    #__init__和#__del__只可被定义为方法，其中#__init__用于定义构造函数，#__del__用于定义析构函数。若这两个方法被缺省，其函数句柄被自动指定为0。构造函数和析构函数只有一个参数，即对象本身。

    若方法有不止一个参数，则方法被调用时，第一个参数总是传入对象本身，相当于C++的this指针。

    约定：类名称以字母c开头；私有数据成员以pv开头；公有数据成员以pl开头；方法成员以m开头。

    sys::obj{pClass}：创建类对象

    pClass是类定义的句柄。

    创建类对象时，将自动调用每一个基类的构造函数#__init__初始化基类对象。对象被销毁时，将自动调用每一个基类的析构函数#__del__销毁基类对象。

    语句 a.=b 将对象b的内容复制到对象a，要求a和b具有相同的类定义，若类定义中定义了方法#__copy__（有且只有2个参数），将自动调用该方法进行对象复制，否则仅依次复制类成员的值。

 

    （1）类定义

!!!using("sys");
new[class, #人, public : #姓名, private : #性别, #年龄].o[];    //用函数new定义类，有1个公有成员，2个私有成员。函数o用于输出类定义。

    结果：

class{#人 : 
private:
  #性别, #年龄, 
public:
  #姓名, 
method:
  #__init__ : 0, #__del__ : 0
}

    用函数class定义类更为方便：

!!!using("sys");
class[#人, public : #姓名, private : #性别, #年龄].o[];    //用函数new定义类，有1个公有成员，2个私有成员。函数o用于输出类定义。

    输出结果与上面相同。

    （2）单一继承

!!!using("sys");
class[#人, public : #姓名, private : #性别, #年龄],
class[#学生, #人, public : #学校, #班级].o[];

    结果：

class{#学生 : #人,
private:

public:
  #学校, #班级,
method:
  #__init__ : 0, #__del__ : 0
}

    （3）类对象

!!!using("sys");
main(:a,b)=
  class[#人, public : #姓名, #性别, #年龄],
  a=class[#学生, #人, public : #学校, #班级],
  b=obj[a],
  b.#学校="实验中学", b.#班级="二年级", b.#姓名="王强", b.#性别="男", b.#年龄=12,
  o[b, b.#学校,"  ", b.#班级,"  ", b.#姓名,"  ", b.#性别, "  ", b.#年龄, "\r\n"];

    结果：

class obj{#学生 : #人,
private:
public:
  #学校 : 实验中学,
  #班级 : 二年级
}
实验中学 二年级 王强 男 12

    说明：如果基类“#人”中#性别和#年龄被定义为私有成员，将无法直接进行存取。

    （4）多重继承及构造函数和析构函数

    例子1：

!!!using("sys");
initA(p)= o["\r\nA的构造函数!"];
initB(p)= o["\r\nB的构造函数!"];
initC(p)= o["\r\nC的构造函数!"];
initD(p)= o["\r\nD的构造函数!"];
delA(p) = o["\r\nA的析构函数!"];
delB(p) = o["\r\nB的析构函数!"];
delC(p) = o["\r\nC的析构函数!"];
delD(p) = o["\r\nD的析构函数!"];
main()=
  class[#A,         method : #__init__ : @initA, #__del__ : @delA],
  class[#B, #A,     method : #__init__ : @initB, #__del__ : @delB],
  class[#C, #A,     method : #__init__ : @initC, #__del__ : @delC],
  class[#D, #B, #C, method : #__init__ : @initD, #__del__ : @delD].obj[].delete[];

    结果：

A的构造函数!
B的构造函数!
A的构造函数!
C的构造函数!
D的构造函数!
D的析构函数!
B的析构函数!
A的析构函数!
C的析构函数!
A的析构函数!

    例子2：

!!!using("sys");
initA(p)= p.#a=0;
initB(p)= p.#a=1;
initC(p)= p.#a=2;
initD(p)= p.#a=3;
main(:c)=
  class[#A,           public: #a, method : #__init__ : @initA],
  class[#B, #A,       public: #a, method : #__init__ : @initB],
  class[#C, #A,       public: #a, method : #__init__ : @initC],
  c=class[#D, #B, #C, public: #a, method : #__init__ : @initD].obj[],
  o[c.#a,"  ",c.#B.#a,"  ",c.#C.#a,"  ",c.#B.#A.#a,"  ",c.#C.#A.#a,"\r\n"],
  c.#B.#A.#a=5, c.#C.#A.#a=6, o[c.#B.#A.#a,"  ",c.#C.#A.#a,"\r\n"];

    结果：

3 1 2 0 0
5 6

    例子3：

!!!using("sys");
initA(p)= p.#a=0;
initB(p)= p.#b=1;
initC(p)= p.#c=2;
initD(p)= p.#d=3;
main(:c)=
  class[#A,           public: #a, method : #__init__ : @initA],
  class[#B, #A,       public: #b, method : #__init__ : @initB],
  class[#C, #A,       public: #c, method : #__init__ : @initC],
  c=class[#D, #B, #C, public: #d, method : #__init__ : @initD].obj[],
  o[c.#a,"  ",c.#b,"  ",c.#c,"  ",c.#d,"\r\n"],
  c.#a=5, c.#b=6, c.#c=7, c.#d=8,
  o[c.#a,"  ",c.#b,"  ",c.#c,"  ",c.#d,"\r\n"],
  c.#B.#A.#a=11, c.#C.#A.#a=12, o[c.#a," ",c.#B.#A.#a,"  ",c.#C.#A.#a,"\r\n"];

    结果：

0 1 2 3
5 6 7 8
11 11 12

    （5）成员函数：第一个参数为对象指针

    例子1：

!!!using("sys");
setA(p,x)= p.#a=x;
setB(p,x)= p.#a=x;
setC(p,x)= p.#a=x;
getA(p)= p.#a;
getB(p)= p.#a;
getC(p)= p.#a;
main(:c)=
  class[#A,           private: #a, method : #mGetA : @getA, #mSetA : @setA],
  class[#B,           private: #a, method : #mGetB : @getB, #mSetB : @setB],
  c=class[#C, #A, #B, private: #a, method : #mGetC : @getC, #mSetC : @setC].obj[],
  c.#mSetA=5, c.#mSetB=6, c.#mSetC=7,
  o[c.#mGetA,"  ",c.#mGetB,"  ",c.#mGetC,"\r\n"];

    结果：

5 6 7

    说明：类的方法成员和数据成员用法几乎相同，但方法可以接受多个参数，如下例。

    例子2：

!!!using("sys");
out(p,x,y,z)= o[x,y,z,"\r\n"];
main(:c)=
  c=class[#A, method : #mOut : @out].obj[],
  c.#mOut := [5,6,7],
  c.#mOut."***".(888)."***";

    结果：

567
***888***

    （6）类对象复制

!!!using("sys");
setA(p,x,y)= p.#a=x, p.#b=y;
sumA(p)= p.#a+p.#b;
copyAB(s,t)= s.#a=t.#a, s.#b=t.#b;
class[#A,     private : #a, public : #b, method : #__copy__ : @copyAB, #setA : @setA, #sumA : @sumA],
class[#B, #A, private : #a, public : #b, method : #__copy__ : @copyAB];
main(:a,b)=
  a=obj[class_handle(#B)], b=obj[class_handle(#B)],
  a.#a=1, a.#b=2, a.#setA:=[8,9],
  b.=a,
  b.#a+b.#b+b.#sumA;

    结果：

20

    （7）多态性

!!!using("sys");
getA()= 1;
getB()= 2;
getC()= 3;
class[#A,     method : #mGet : @getA],
class[#B, #A, method : #mGet : @getB],
class[#C, #B, method : #mGet : @getC];
main(:a,b,c)=
  c=obj[class_handle(#C)],
  o[c.#mGet,"  ",c.#B.#mGet,"  ",c.#B.#A.#mGet,"\r\n"],
  b=c.#B, a=b.#A,  //获得基类对象
  o[c.#mGet,"  ",b.#mGet,"  ",a.#mGet,"\r\n"];

    结果：

3 2 1
3 2 1

    （8）效率测试

!!!using("sys");
main(:a,i,t0,sum)=
  a=class{#A,
    public:
    #January,
    #February,
    #March,
    #April,
    #May,
    #June,
    #July,
    #August,
    #September,
    #October,
    #November,
    #December
  }.obj[],
  t0=clock(), sum=0,
  i=0, while{++i<=100000,
    a.#January=1,
    a.#February=2,
    a.#March=3,
    a.#April=4,
    a.#May=5,
    a.#June=6,
    a.#July=7,
    a.#August=8,
    a.#September=9,
    a.#October=10,
    a.#November=11,
    a.#December=12,
    sum=sum+a.#January+a.#February+a.#March+a.#April+a.#May+a.#June+a.#July+a.#August+a.#September+a.#October+a.#November+a.#December
  },
  o{"\r\n耗时", [clock()-t0]/1000., "秒。sum=", sum, "\r\n"};

    结果：

耗时0.85999999999999999秒。sum=7800000