Coo - C, Object Oriented

[pan_0326]

目的
----
用C语言可以方便地进行面向对象编程,可以继承、多继承、使用虚函数、基类成员
直接引用、基类整体直接引用...
实现中很少使用强制类型转换，充分利用C语言的类型检查查错。现在只在虚表初始
化中使用了强制类型转换，需要小心，以后可以改进编译器避免强制类型转换。

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

http://sourceforge.net/projects/coo/
email: [e-mail]
blog: http://blog.163.com/coo_bin/

[zenny_chen]

呵呵，熟练使用C99能够省去很多事情。
其实，如果一款C编译器能实现90%的C99标准，那么基本上就足够了。
C++的话，关键还是在于其强大的泛型机制。

[pan_0326]

C++的template确实很神奇,但OO也是不容忽视的,否则java和obj-c怎么火起来的?
C语言无法高效地书写OO程序,不能说不是个遗憾,Coo可以简单实现OO.

[acdbxzyw]

咦，楼主所说的特性不是C++才有的吗？

[pan_0326]

举个简单例子，先看C++的：
class CBase
{
public:
int a;
};
class CThis : public CBase
{
public:
int b;
};
CThis t;
t.a=1;
CBase* p=&t;

下面是Coo的：
#include "coo.h"
typedef struct CBase
{
int a;
} CBase;
typedef struct CThis
{
EXTENDS(CBase) //继承
int b;
} CThis;
CThis t;
t.a=1; //基类成员直接引用
CBase* p=&t.CBase; //基类整体直接引用

[pan_0326]

举个简单例子，先看C++的：
class CBase
{
public:
int a;
};
class CThis : public CBase
{
public:
int b;
};
CThis t;
t.a=1;
CBase* p=&t;

下面是Coo的：
#include "coo.h"
typedef struct CBase
{
int a;
} CBase;
typedef struct CThis
{
EXTENDS(CBase) //继承
int b;
} CThis;
CThis t;
t.a=1; //基类成员直接引用
CBase* p=&t.CBase; //基类整体直接引用

[zenny_chen]

呵呵，晕菜。C语言还用的那么复杂干啥？

[pan_0326]

面向对象编程思想是很重要的,C语言也能做,但是书写非常麻烦易出错.
遵循Coo.h规范,书写面向对象程序变得非常方便,而且不易出错.
熟练掌握了Coo,还可以深刻理解C++中的面向对象的底层实现.

[zenny_chen]

[Quote=引用 5 楼 pan_0326 的回复:]

面向对象编程思想是很重要的,C语言也能做,但是书写非常麻烦易出错.
遵循Coo.h规范,书写面向对象程序变得非常方便,而且不易出错.
熟练掌握了Coo,还可以深刻理解C++中的面向对象的底层实现.
[/Quote]
噗嗤！
OOP在很多场合都是累赘……

[东莞某某某]

淡定 ，关注下。

[pan_0326]

滥用的结果当然如你所说
但你也不敢说所有场合,用得好是趁手的兵器,用不好是海底的废铁

[pan_0326]

再举个复杂例子，先看C++的：

class CBase //基类
{
public:
int a;
CBase();
virtual int GetA() const; //带虚函数
};
int CBase::GetA() const
{
return a;
}
int CBase::CBase()
{
a=0;
}

class CInterface //接口
{
public:
//接口没数据
virtual void Inc()=0;
};

class CThis : public CBase, public CInterface //多继承
{
public:
int b;
CThis();
virtual int GetA() const; //重载
virtual void Inc(); //实现
virtual int GetB() const;
};
int CThis::GetA() const
{
return a+1;
}
void CThis::Inc()
{
a++;
}
int CThis::GetB() const
{
return b;
}
void CThis::CThis()
{
b=1;
}

int main()
{
CThis* pt=new CThis();
CInterface* p=pt;
p->Inc();
delete p; //ERROR!
return 0;
}

下面是Coo的：

#include "coo.h"
struct VBase;
typedef struct CBase
{
VT(struct VBase) //虚表指针,模仿C++
int a;
} CBase;
typedef struct VBase //基类虚表类
{
EXTENDS(VTable) //便于FREE
int (*GetA)(const CBase*); //虚函数
} VBase;
int CBase_GetA(const CBase* pThis)
{
return pThis->a;
}
const VBase _VBase=
{
0,
CBase_GetA,
};
void CBase_CBase(CBase* pThis) //构造函数
{
pThis->vt=&_VBase; //显式装配虚表指针
pThis->a=0;
}

typedef struct CInterface
{
//接口没数据
} CInterface;
typedef struct VInterface //接口虚表类
{
EXTENDS(VTable) //便于FREE
void (*Inc)(CInterface*); //虚函数
} VInterface;

struct VThis;
typedef struct CThis
{
EXTENDS(CInterface) //空的，占位
EXTENDS2(CBase,struct VThis) //多继承
int b;
} CThis;
typedef struct VThis
{
EXTENDS(VBase) //继承
EXTENDS(VInterface) //虚表类也多继承
int (*GetB)(const CThis*); //虚函数
} VThis;
int CThis_GetA(const CThis* pThis)
{
return pThis->a+1; //基类成员直接引用
}
void CThis_Inc(CThis* pThis)
{
pThis->a++;
}
int CThis_GetB(const CThis* pThis)
{
return pThis->b;
}
const VThis _VThis=
{
0,
(int (*)(const CBase*))CThis_GetA, //强制类型转换，小心
0,
(void (*)(CInterface*))CThis_Inc,
CThis_GetB,
};
void CThis_CThis(CThis* pThis) //构造函数
{
pThis->vt=&_VThis; //显式装配虚表指针
pThis->b=1;
}

int main()
{
CThis* pt=(CThis*)malloc(sizeof(CThis));
CThis_CThis(pt); //显式调用构造函数
CInterface* p=&pt->CInterface; //基类整体直接引用
pt->vt->VInterface.Inc(p); //虚函数调用 pt->vt->VInterface是p的虚表
FREE(p,&pt->vt->VInterface); //OK!
return 0;
}

[xhp7185]

和C++有什么区别

[pan_0326]

[Quote=引用 10 楼 xhp7185 的回复:]

和C++有什么区别
[/Quote]

仍然不如C++
无法自动析构...

[yangyunzhao]

[Quote=引用 11 楼 pan_0326 的回复:]
引用 10 楼 xhp7185 的回复:

和C++有什么区别


仍然不如C++
无法自动析构...
[/Quote]
不如C++，而且语法晦涩。干嘛用它？

[pan_0326]

coo.h非常简单,核心部分就下面几行
当只使用C时有帮助

#ifndef __COO_H__
#define __COO_H__

typedef struct VTable /*root of every virtual table class*/
{
long offset; /*servers for FREE*/
} VTable;

#define EXTENDS(s) \
union \
{ \
s s; \
s; \
};
#define VT(v) const v* vt;
#define EXTENDS2(s,v) \
union \
{ \
VT(v) \
s s; \
s; \
};
#ifndef offsetof
#define offsetof(s,m) ((long)&((s*)0)->m)
#endif
#define SUPER(s,m,p) ((s*)((char*)(p)-offsetof(s,m)))
#define FREE(p,vt) free((char*)(p)-(vt)->offset)

#endif

[时间一粒]

学习！

[pan_0326]

#include "coo.h"
struct VBase;
typedef struct CBase
{
VT(struct VBase) //虚表指针,模仿C++
int a;
} CBase;
typedef struct VBase //基类虚表类
{
EXTENDS(VTable) //便于FREE
int (*GetA)(const CBase*); //虚函数
} VBase;
int CBase_GetA(const CBase* pThis)
{
return pThis->a;
}
const VBase _VBase=
{
0,
CBase_GetA,
};
void CBase_CBase(CBase* pThis) //构造函数
{
pThis->vt=&_VBase; //显式装配虚表指针
pThis->a=0;
}

上面是Coo的虚函数例子,显式嵌入虚表指针、显式定义虚表类、显式定义虚表常量
和显式装配虚表指针。这些就是C++在背后做的事情，即便作为C++程序员都应该了
解一些这些知识，事情虽多，但从上面代码来看并不复杂，会用Coo中的虚函数，也
就掌握了C++中OO多态的实现原理。