詳解coo-1.0.2中的自動(dòng)析構(gòu)

pan_0326

coo-1.0.2發(fā)布了,通過修改升級tcc到tcc-0.9.25.2,實(shí)現(xiàn)了一些擴(kuò)展.
其中最重要的是自動(dòng)析構(gòu)特性:
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++自動(dòng)析構(gòu)的例子,也是典型的RAII.return 0之前會(huì)自動(dòng)調(diào)
用~CFile(),這是明顯優(yōu)點(diǎn),但也有些遺憾,return 1之前其實(shí)根本不想
調(diào)用~CFile(),但無法辦到.這也就是為什么C++會(huì)比C大一些慢一些的一
個(gè)原因.
typedef struct CFile {
    FILE* fp;
} CFile;
void CFile_CFile(CFile* pThis, const char* name)
{
    pThis->fp=fopen(name,"rt");
}
void CFile_(CFile* pThis) //規(guī)范析構(gòu)函數(shù)
{
    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中自動(dòng)析構(gòu),只要定義了析構(gòu)函數(shù)CFile_(規(guī)定加_),return 0
之前就會(huì)自動(dòng)調(diào)用.而且Coo走得更遠(yuǎn),增加關(guān)鍵字struct_,功能是抑制自
動(dòng)析構(gòu),所以return 1之前不會(huì)調(diào)用CFile_(&file).struct_起名是與析
構(gòu)函數(shù)保持一致的,可以理解為通用析構(gòu),所以不用再自動(dòng)析構(gòu)了.而且
struct_(file)不是一個(gè)完整語句,所以return 1仍然在if范圍內(nèi).
自動(dòng)析構(gòu)不僅發(fā)生在return前,還包括break continue和},goto不包括在
內(nèi).為了彌補(bǔ)這個(gè)小缺陷,Coo還加強(qiáng)了break和continue,允許帶一常數(shù)參
數(shù)表示層數(shù):
int i,j;
for (i=0; i<3; i++)
    for (j=0; j<3; j++)
        if (...) break 2; //goto tt;
//tt:
上面break 2可以跳到tt,此擴(kuò)展比java的好,可以完全不用標(biāo)號.
最后再說說C++中的auto_ptr在Coo中的實(shí)現(xiàn),這也是典型的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是根據(jù)自動(dòng)析構(gòu)規(guī)范寫的一個(gè)宏,AUTOPTR(int)得到自動(dòng)指針類
intp.定義了自動(dòng)指針變量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/