用C编写面向对象代码有哪些方法?特别是在多态性方面。
另请参阅此堆栈溢出问题C中的面向对象。
当前回答
C的stdio FILE子库是如何在纯C中创建抽象、封装和模块化的极好示例。
继承和多态性——通常被认为是OOP必不可少的其他方面——不一定能提供它们所承诺的生产率提高，而且有合理的理由认为它们实际上会阻碍开发和对问题域的思考。
其他回答
当然这是可能的。这就是所有GTK+和GNOME所基于的框架GObject所做的工作。
既然你说的是多态性，那么是的，你可以，我们在c++出现之前几年就已经在做这类事情了。
基本上，你使用一个结构体来保存数据和一个函数指针列表，以指向该数据的相关函数。
因此，在一个通信类中，你会有一个打开、读、写和关闭调用，它将被维护为结构中的四个函数指针，与对象的数据一起，类似于:
typedef struct {
int (*open)(void *self, char *fspec);
int (*close)(void *self);
int (*read)(void *self, void *buff, size_t max_sz, size_t *p_act_sz);
int (*write)(void *self, void *buff, size_t max_sz, size_t *p_act_sz);
// And data goes here.
} tCommClass;
tCommClass commRs232;
commRs232.open = &rs232Open;
: :
commRs232.write = &rs232Write;
tCommClass commTcp;
commTcp.open = &tcpOpen;
: :
commTcp.write = &tcpWrite;
当然，上面的那些代码段实际上是在诸如rs232Init()这样的“构造函数”中。
当你“继承”这个类时，你只需要改变指针指向你自己的函数。每个调用这些函数的人都会通过函数指针来做，给你你的多态性:
int stat = (commTcp.open)(commTcp, "bigiron.box.com:5000");
有点像手动虚表。
你甚至可以通过将指针设置为NULL来创建虚拟类——这与c++的行为略有不同(运行时的核心转储而不是编译时的错误)。
下面是一段演示它的示例代码。首先是顶级类结构:
#include <stdio.h>
// The top-level class.
typedef struct sCommClass {
int (*open)(struct sCommClass *self, char *fspec);
} tCommClass;
然后我们有TCP '子类'的函数:
// Function for the TCP 'class'.
static int tcpOpen (tCommClass *tcp, char *fspec) {
printf ("Opening TCP: %s\n", fspec);
return 0;
}
static int tcpInit (tCommClass *tcp) {
tcp->open = &tcpOpen;
return 0;
}
HTTP也是一样:
// Function for the HTTP 'class'.
static int httpOpen (tCommClass *http, char *fspec) {
printf ("Opening HTTP: %s\n", fspec);
return 0;
}
static int httpInit (tCommClass *http) {
http->open = &httpOpen;
return 0;
}
最后是一个测试程序来展示它的作用:
// Test program.
int main (void) {
int status;
tCommClass commTcp, commHttp;
// Same 'base' class but initialised to different sub-classes.
tcpInit (&commTcp);
httpInit (&commHttp);
// Called in exactly the same manner.
status = (commTcp.open)(&commTcp, "bigiron.box.com:5000");
status = (commHttp.open)(&commHttp, "http://www.microsoft.com");
return 0;
}
这将产生输出:
Opening TCP: bigiron.box.com:5000
Opening HTTP: http://www.microsoft.com
你可以看到不同的函数被调用，取决于子类。
命名空间通常通过以下方式实现:
stack_push(thing *)
而不是
stack::push(thing *)
要将C结构体变成类似c++类的东西，您可以转向:
class stack {
public:
stack();
void push(thing *);
thing * pop();
static int this_is_here_as_an_example_only;
private:
...
};
Into
struct stack {
struct stack_type * my_type;
// Put the stuff that you put after private: here
};
struct stack_type {
void (* construct)(struct stack * this); // This takes uninitialized memory
struct stack * (* operator_new)(); // This allocates a new struct, passes it to construct, and then returns it
void (*push)(struct stack * this, thing * t); // Pushing t onto this stack
thing * (*pop)(struct stack * this); // Pops the top thing off the stack and returns it
int this_is_here_as_an_example_only;
}Stack = {
.construct = stack_construct,
.operator_new = stack_operator_new,
.push = stack_push,
.pop = stack_pop
};
// All of these functions are assumed to be defined somewhere else
和做的事:
struct stack * st = Stack.operator_new(); // Make a new stack
if (!st) {
// Do something about it
} else {
// You can use the stack
stack_push(st, thing0); // This is a non-virtual call
Stack.push(st, thing1); // This is like casting *st to a Stack (which it already is) and doing the push
st->my_type.push(st, thing2); // This is a virtual call
}
我没有做析构函数或删除，但它遵循相同的模式。
This_is_here_as_an_example_only类似于一个静态类变量——在一个类型的所有实例之间共享。所有的方法都是静态的，除了一些采用this *
这个问题的答案是“是的，你可以”。
面向对象的C (OOC)工具包是为那些希望以面向对象的方式进行编程的人准备的，但它也沿用了优秀的老C。OOC实现了类、单继承和多继承、异常处理。
特性
•只使用C宏和函数，不需要语言扩展!(ansi c)
•易于阅读的源代码为您的应用程序。小心翼翼地使事情尽可能简单。
•类的单一继承
•通过接口和mixin进行多重继承(从1.3版开始)
•实现异常(纯C!)
•类的虚函数
•易于类实现的外部工具
欲了解更多详情，请访问http://ooc-coding.sourceforge.net/。
我认为首先要说的是(至少在我看来)C的函数指针实现真的很难使用。我会跳过一大堆的圆环来避免函数指针…
也就是说，我认为其他人说的很好。你有结构，你有模块，而不是foo->方法(a,b,c)，你最终用方法(foo,a,b,c)如果你有一个“method”方法，那么你可以用类型前缀它，所以FOO_method(foo,a,b,c)，正如其他人所说…通过良好地使用.h文件，您可以获得私有和公共文件，等等。
现在，有一些事情是这个技巧不能给你的。它不会提供私有数据字段。我认为，这与意志力和良好的编码习惯有关……而且，没有一种简单的方法来继承它。
这些至少是简单的部分……其余的，我认为是90/10的情况。10%的收益需要90%的工作……
