详解coo-1.0.2中的自动析构

pan_0326

coo-1.0.2发布了,通过修改升级tcc到tcc-0.9.25.2,实现了一些扩展.
其中最重要的是自动析构特性:
class CFile {
public:
    FILE* fp;
    CFile(const char* name)
    {
        fp=fopen(name,"rt");
    }
    ~CFile()
    {
        if (fp)
            fclose(fp);
    }
};
int main()
{
    CFile file("coo.txt");
    if (!file.fp)
        return 1;
    //...
    return 0;
}
上面就是C++自动析构的例子,也是典型的RAII.return 0之前会自动调
用~CFile(),这是明显优点,但也有些遗憾,return 1之前其实根本不想
调用~CFile(),但无法办到.这也就是为什么C++会比C大一些慢一些的一
个原因.
typedef struct CFile {
    FILE* fp;
} CFile;
void CFile_CFile(CFile* pThis, const char* name)
{
    pThis->fp=fopen(name,"rt");
}
void CFile_(CFile* pThis) //规范析构函数
{
    if (pThis->fp)
        fclose(pThis->fp);
}
int main()
{
    CFile file;
    CFile_CFile(&file,"coo.txt");
    if (!file.fp)
        struct_(file) return 1; //don't call CFile_(&file);
    //...
    return 0; //auto call CFile_(&file);
}
上面是Coo中自动析构,只要定义了析构函数CFile_(规定加_),return 0
之前就会自动调用.而且Coo走得更远,增加关键字struct_,功能是抑制自
动析构,所以return 1之前不会调用CFile_(&file).struct_起名是与析
构函数保持一致的,可以理解为通用析构,所以不用再自动析构了.而且
struct_(file)不是一个完整语句,所以return 1仍然在if范围内.
自动析构不仅发生在return前,还包括break continue和},goto不包括在
内.为了弥补这个小缺陷,Coo还加强了break和continue,允许带一常数参
数表示层数:
int i,j;
for (i=0; i<3; i++)
    for (j=0; j<3; j++)
        if (...) break 2; //goto tt;
//tt:
上面break 2可以跳到tt,此扩展比java的好,可以完全不用标号.
最后再说说C++中的auto_ptr在Coo中的实现,这也是典型的RAII:
int main()
{
    int* p=malloc(sizeof(int));
    auto_ptr<int> x(p);
    return 0;
}
以上是C++中auto_ptr的例子,下面是Coo的:
AUTOPTR(int)
int main()
{
    intp x = {malloc(sizeof(int))};
    //x.p
    return 0; //auto call free(x.p);
}
AUTOPTR是根据自动析构规范写的一个宏,AUTOPTR(int)得到自动指针类
intp.定义了自动指针变量x后使用x.p即可.

http://sourceforge.net/projects/coo/

pan_0326

Coo - C, Object Oriented

Compiler
--------
1. gcc
   gcc -fms-extensions
2. tcc-0.9.25.1

Rules of Coo
------------
1. define class
typedef struct CBase { int a; ... } CBase;
typedef struct CBase { VT(VBase) ... } CBase;
    //include pointer of vitual table, its name must be "vt", it must be the first member
typedef struct CInterface {} CInterface;
    //may be empty, sizeof equals 0, align equals 1
2. inherit
typedef struct CThis { EXTENDS(CBase) ... } CThis;
typedef struct CThis { EXTENDS2(CBase,VThis) ... } CThis;
    //covers old pointer of vitual table
typedef struct CThis { EXTENDS(CBase) EXTENDS(CInterface) ... } CThis;
    //multiple inherits
typedef struct CThis { EXTENDS(CInterface) EXTENDS2(CBase,VThis) ... } CThis;
    //if CInterface is empty, may put it on the top
3. define vitual table class
typedef struct VBase { int (*Get)(const CBase*); ... } VBase;
typedef struct VBase { EXTENDS(VTable) ... } VBase;
    //advice to inherit from VTable, can use macro FREE
4. vitual table class inherit
typedef struct VThis { EXTENDS(VBase) ... } VThis;
typedef struct VThis { EXTENDS(VBase) EXTENDS(VInterface) ... } VThis;
    //multiple inherits too
5. visit member and base class
typedef struct CBase { int a; ... } CBase;
    typedef struct CThis { EXTENDS(CBase) ... } CThis;
    CThis t;
    //t.CBase is better than *(CBase*)&t
    //t.a is better than t.CBase.a
6. define vitual function
typedef struct VBase { int (*Get)(const CBase*); ... } VBase;
    int CBase_Get(const CBase* pThis) { return pThis->a; }
    typedef struct VThis { EXTENDS(VBase) ... } VThis;
    int CThis_CBase_Get(const CBase* pThis) { const CThis* p=SUPER(CThis,CBase,pThis); ... }
    //covers vitual function
    //macro SUPER coverts current class pointer to super class pointer
7. define vitual table
VBase _VBase={ CBase_Get, };
VThis _VThis={ ... offsetof(CThis,CBase), CThis_CBase_Get, ... };
    //don't use type conversion as much as possible
    //macro offsetof servers for macro FREE
8. constructor
void CBase_CBase(CBase* pThis) { ... }
void CBase_CBase(CBase* pThis) { pThis->vt=&_VBase; ... }
    //install the pointer of vitual table
9. FREE
typedef struct CThis { EXTENDS(CBase) EXTENDS(CBase1) ... } CThis;
    CThis* pThis; ... CBase1* p=&pThis->CBase1;
    FREE(p,p->vt);
10. virtual inherit
typedef struct CBase { ... } CBase;
    typedef struct _CT1 { CBase* pCBase; ... } _CT1;
    typedef struct _CT2 { CBase* pCBase; ... } _CT2;
    typedef struct CThis { EXTENDS(_CT1) EXTENDS(_CT2) EXTENDS(CBase) ... } CThis;

Additions(tcc-0.9.25.2)
-----------------------
1. __COO__
#ifdef __COO__
    ...
    #endif
2. initialize of union
union { int i; double f; } u = 1.5;
    //initiate the last member of union
3. sizeof_
struct C { int i; short n; } c, array[1];
    //sizeof(struct C)==8, sizeof_(struct C)==6
    //sizeof_(c)==6, sizeof_(array)==sizeof(array)==8
4. define destructor
struct C { ... };
    void C_(struct C* pThis) { ... }
    //<destructor name> = <struct name> + '_'
5. call destructor
{ struct C c, p[1];
    } //auto call C_(&c); don't call C_(p);
    //before },break,continue,return
6. limit destructor
{ struct C c;
    struct_(c); //limit
    } //don't call C_(&c);
7. AUTOPTR
AUTOPTR(int)
    { intp a = {0}; //a.p = 0;
    } //auto call free(a.p);
8. break [n]; and continue [n];
for (i=0; i<5; i++)
    for (j=0; j<4; j++)
        break 2; //continue 2;
    //break;==break 1;
    //continue;==continue 1;

-------------------------
email: yuanbin0@gmail.com
blog: http://blog.163.com/coo_bin/