blocks|key|3303789|text|我的方法是将struct和所有主要相关的函数移到单独的源文件中，以便可以“可移植”地使用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3303790|根据您的编译器，您可能能够将函数包含到struct中，但这是一个特定于的编译器扩展，与我经常使用的标准的最新版本无关:)|BOLD|3303791|entityMap^0|6|6|0|J|6|Z|1|0^^$0|@$1|2|3|4|5|6|7|K|8|@$9|L|A|M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|H]]|D|@]|E|$]]|$1|I|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|J|$]]

My approach would be to move the <code>struct</code> and all primarily-associated functions to a separate source file(s) so that it can be used "portably".

Depending on your compiler, you might be able to include functions into the <code>struct</code>, but that's a very compiler-specific extension, and has nothing to do with the last version of the standard I routinely used :)

blocks|key|3090986|text|正如您正确指出的那样，C不是一种OOP语言，因此没有内置的方法来编写真正的类。最好的办法是看看structs和function+pointers，它们可以让你构建一个近似的类。然而，由于C是过程化的，你可能想要考虑编写更多类似C的代码(即不尝试使用类)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3090987|同样，如果你可以使用C，你也可以使用C%2B%2B和get类。|3090988|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Struct_(C_programming_language))|1|http://en.wikipedia.org/wiki/Function_pointer^0|1B|7|0|1J|H|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

C isn't an OOP language, as your rightly point out, so there's no built-in way to write a true class. You're best bet is to look at <a href="http://en.wikipedia.org/wiki/Struct_(C_programming_language)" rel="nofollow noreferrer">structs</a>, and <a href="http://en.wikipedia.org/wiki/Function_pointer" rel="nofollow noreferrer">function pointers</a>, these will let you build an approximation of a class. However, as C is procedural you might want to consider writing more C-like code (i.e. without trying to use classes).

Also, if you can use C, you can probally use C++ and get classes.

blocks|key|329251|text|在您的例子中，类的最佳近似值可能是一个ADT。但它仍然不会是一样的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|329252|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Abstract_data_type^0|J|3|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

In your case the good approximation of the class could be the an <a href="http://en.wikipedia.org/wiki/Abstract_data_type" rel="nofollow noreferrer">ADT</a>. But still it won't be the same.

blocks|key|3303877|text|这取决于你想要的确切的“面向对象的”特性集。如果你需要像重载和/或虚方法这样的东西，你可能需要在结构中包含函数指针：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3303878|typedef+struct+{
++float+(*computeArea)(const+ShapeClass+*shape);
}+ShapeClass;

float+shape_computeArea(const+ShapeClass+*shape)
{
++return+shape->computeArea(shape);
}|code-block|syntax|javascript|3303879|这将允许您通过“继承”基类并实现适当的函数来实现一个类：|3303880|typedef+struct+{
++ShapeClass+shape;
++float+width,+height;
}+RectangleClass;

static+float+rectangle_computeArea(const+ShapeClass+*shape)
{
++const+RectangleClass+*rect+=+(const+RectangleClass+*)+shape;
++return+rect->width+*+rect->height;
}|3303881|当然，这也需要你实现一个构造函数，以确保函数指针被正确设置。通常情况下，您会为实例动态分配内存，但您也可以让调用者这样做：|3303882|void+rectangle_new(RectangleClass+*rect)
{
++rect->width+=+rect->height+=+0.f;
++rect->shape.computeArea+=+rectangle_computeArea;
}|3303883|如果你想要几个不同的构造函数，你将不得不“修饰”函数名，你不能有多个rectangle_new()函数：|offset|length|style|CODE|3303884|void+rectangle_new_with_lengths(RectangleClass+*rect,+float+width,+float+height)
{
++rectangle_new(rect);
++rect->width+=+width;
++rect->height+=+height;
}|3303885|下面是一个基本的用法示例：|3303886|int+main(void)
{
++RectangleClass+r1;

++rectangle_new_with_lengths(&r1,+4.f,+5.f);
++printf("rectangle+r1's+area+is+%25f+units+square\n",+shape_computeArea(&r1));
++return+0;
}|3303887|我希望这至少能给你一些启发。要获得成功且丰富的C面向对象框架，请查看glib的GObject库。|3303888|还要注意，上面没有显式的“类”被建模，每个对象都有自己的方法指针，这比你通常在C%2B%2B中找到的要灵活一点。此外，它还会占用内存。您可以通过在class结构中填充方法指针来避免这种情况，并发明一种方法让每个对象实例引用一个类。|3303889|entityMap|0|LINK|mutability|MUTABLE|url|http://library.gnome.org/devel/gobject/stable/^0|0|0|0|0|0|0|Y|F|0|0|0|0|13|7|0|0|1X|5|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1E|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1I|8|@$Q|1J|R|1K|S|T]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1O|8|@]|9|@$Q|1P|R|1Q|1|1R]]|A|$]]|$1|12|3|13|5|6|7|1S|8|@$Q|1T|R|1U|S|T]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]]]

That depends on the exact "object-oriented" feature-set you want to have. If you need stuff like overloading and/or virtual methods, you probably need to include function pointers in structures:

<pre><code>typedef struct {
 float (*computeArea)(const ShapeClass *shape);
} ShapeClass;

float shape_computeArea(const ShapeClass *shape)
{
 return shape-&gt;computeArea(shape);
}
</code></pre>

This would let you implement a class, by "inheriting" the base class, and implementing a suitable function:

<pre><code>typedef struct {
 ShapeClass shape;
 float width, height;
} RectangleClass;

static float rectangle_computeArea(const ShapeClass *shape)
{
 const RectangleClass *rect = (const RectangleClass *) shape;
 return rect-&gt;width * rect-&gt;height;
}
</code></pre>

This of course requires you to also implement a constructor, that makes sure the function pointer is properly set up. Normally you'd dynamically allocate memory for the instance, but you can let the caller do that, too:

<pre><code>void rectangle_new(RectangleClass *rect)
{
 rect-&gt;width = rect-&gt;height = 0.f;
 rect-&gt;shape.computeArea = rectangle_computeArea;
}
</code></pre>

If you want several different constructors, you will have to "decorate" the function names, you can't have more than one <code>rectangle_new()</code> function:

<pre><code>void rectangle_new_with_lengths(RectangleClass *rect, float width, float height)
{
 rectangle_new(rect);
 rect-&gt;width = width;
 rect-&gt;height = height;
}
</code></pre>

Here's a basic example showing usage:

<pre><code>int main(void)
{
 RectangleClass r1;

 rectangle_new_with_lengths(&amp;r1, 4.f, 5.f);
 printf("rectangle r1's area is %f units square\n", shape_computeArea(&amp;r1));
 return 0;
}
</code></pre>

I hope this gives you some ideas, at least. For a successful and rich object-oriented framework in C, look into glib's <a href="http://library.gnome.org/devel/gobject/stable/" rel="noreferrer">GObject</a> library.

Also note that there's no explicit "class" being modelled above, each object has its own method pointers which is a bit more flexible than you'd typically find in C++. Also, it costs memory. You could get away from that by stuffing the method pointers in a <code>class</code> structure, and invent a way for each object instance to reference a class.

blocks|key|3303925|text|你想要虚拟方法吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3303926|如果没有，那么只需在结构本身中定义一组函数指针即可。如果你把所有的函数指针都赋值给标准的C函数，那么你就可以用与在C%2B%2B下非常相似的语法从C调用函数。|3303927|如果你想拥有虚拟方法，它就会变得更加复杂。基本上，您需要为每个结构实现自己的VTable，并根据调用的函数将函数指针分配给VTable。然后，您需要在结构本身中使用一组函数指针，这些指针反过来调用VTable中的函数指针。从本质上讲，这就是C%2B%2B所做的。|3303928|不过..。如果您想要后者，那么您最好找到一个可以使用的C%2B%2B编译器，然后重新编译项目。我从来不理解为什么C%2B%2B在嵌入式系统中不可用。我已经用过很多次了，它的运行速度很快，而且没有内存问题。当然，你必须对你所做的事情更小心一点，但这真的不是那么复杂。|3303929|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Do you want virtual methods? 

If not then you just define a set of function pointers in the struct itself. If you assign all the function pointers to standard C functions then you will be able to call functions from C in very similar syntax to how you would under C++.

If you want to have virtual methods it gets more complicated. Basically you will need to implement your own VTable to each struct and assign function pointers to the VTable depending on which function is called. You would then need a set of function pointers in the struct itself that in turn call the function pointer in the VTable. This is, essentially, what C++ does.

TBH though ... if you want the latter then you are probably better off just finding a C++ compiler you can use and re-compiling the project. I have never understood the obsession with C++ not being usable in embedded. I've used it many a time and it works is fast and doesn't have memory problems. Sure you have to be a bit more careful about what you do but its really not that complicated.

blocks|key|334261|text|使用struct模拟类的数据成员。就方法范围而言，您可以通过将私有函数原型放在.c文件中，将公共函数放在.h文件中，来模拟私有方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|334262|entityMap^0|2|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Use a <code>struct</code> to simulate the data members of a class. In terms of method scope you can simulate private methods by placing the private function prototypes in the .c file and the public functions in the .h file.

blocks|key|3091167|text|为了做家庭作业，我也做了一次。我遵循了这种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3091168|3091169|在结构中定义数据成员。|ordered-list-item|3091170|定义将指向结构的指针作为第一个参数的函数成员。|3091171|在一个头中执行这些操作&一个c.头用于结构定义和函数声明，c用于implementations.|3091172|3091173|一个简单的例子是：|3091174|///+Queue.h
struct+Queue
{
++++///+members
}
typedef+struct+Queue+Queue;

void+push(Queue*+q,+int+element);
void+pop(Queue*+q);
//+etc.
///+|code-block|syntax|javascript|3091175|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|X|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|10|8|@]|9|@]|A|$P|Q]]|$1|R|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|S|$]]

I had to do it once too for a homework. I followed this approach:

<ol>
<li>Define your data members in a
struct.</li>
<li>Define your function members that
take a pointer to your struct as
first argument.</li>
<li>Do these in one header &amp; one c.
Header for struct definition &amp;
function declarations, c for
implementations.</li>
</ol>

A simple example would be this:

<pre><code>/// Queue.h
struct Queue
{
 /// members
}
typedef struct Queue Queue;

void push(Queue* q, int element);
void pop(Queue* q);
// etc.
/// 
</code></pre>

blocks|key|329332|text|如果只想要一个类，可以使用一个对象数组作为“struct”数据，并将指向它们的指针传递给“成员”函数。您可以在声明struct+_whatever之前使用typedef+struct+_whatever+Whatever向客户端代码隐藏实现。这样的“对象”和C标准库的FILE对象没有区别。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|329333|如果您想要多个具有继承和虚函数的类，则通常将指向函数的指针作为结构的成员，或者将指向虚函数表的共享指针作为结构成员。GObject库同时使用了这种技巧和类型定义技巧，并且得到了广泛的使用。|329334|网上也有一本关于这方面的技术的书-+Object+Oriented+Programming+with+ANSI+C。|329335|entityMap|0|LINK|mutability|MUTABLE|url|http://library.gnome.org/devel/gobject/unstable/|1|http://www.planetpdf.com/developer/article.asp?ContentID=6635^0|M|6|1L|G|25|X|3Q|4|0|1M|7|0|0|I|13|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@$9|13|A|14|1|15]]|E|$]]|$1|H|3|I|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|J|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

If you only want one class, use an array of <code>struct</code>s as the "objects" data and pass pointers to them to the "member" functions. You can use <code>typedef struct _whatever Whatever</code> before declaring <code>struct _whatever</code> to hide the implementation from client code. There's no difference between such an "object" and the C standard library <code>FILE</code> object.

If you want more than one class with inheritance and virtual functions, then it's common to have pointers to the functions as members of the struct, or a shared pointer to a table of virtual functions. The <a href="http://library.gnome.org/devel/gobject/unstable/" rel="noreferrer">GObject</a> library uses both this and the typedef trick, and is widely used. 

There's also a book on techniques for this available online - <a href="http://www.planetpdf.com/developer/article.asp?ContentID=6635" rel="noreferrer">Object Oriented Programming with ANSI C</a>.

blocks|key|3304041|text|第一个c%2B%2B编译器实际上是一个将C%2B%2B代码翻译成C语言的预处理器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3304042|所以用C编写类是很有可能的，你可以试着挖掘出一个旧的C%2B%2B预处理器，看看它创建了什么样的解决方案。|3304043|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The first c++ compiler actually was a preprocessor which translated the C++ code into C.

So it's very possible to have classes in C.
You might try and dig up an old C++ preprocessor and see what kind of solutions it creates.

blocks|key|3304063|text|你可以看看GOBject。它是一个OS库，它为您提供了一种执行对象详细方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3304064|http://library.gnome.org/devel/gobject/stable/|offset|length|3304065|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

you can take a look at GOBject. it's an OS library that give you a verbose way to do an object.

<a href="http://library.gnome.org/devel/gobject/stable/" rel="noreferrer">http://library.gnome.org/devel/gobject/stable/</a>

blocks|key|3304116|text|我的策略是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3304117|3304118|在单独的文件中定义类的所有代码|unordered-list-item|3304119|在单独的头文件中定义类的所有接口|3304120|所有成员函数都采用代表实例名称的"ClassHandle“(而不是o.foo()，调用ClassInit构造函数被替换为ClassHandle+ClassInit(ClassHandle+h，int+x，int+y，...)+)或者ClassHandle+ClassInit(int+x，int+y，...)根据内存分配策略，所有成员变量都作为静态结构的成员存储在类文件中，将其封装在文件中，防止外部文件访问它。对象存储在上面的静态结构的数组中，具有预定义的句柄(在接口中可见)或固定的对象限制(+instantiated|3304121|If+|3304122|3304123|)。该类可以包含公共函数，这些函数将遍历数组并调用所有实例化对象的函数(RunAll()调用每个Run(oHandle)|3304124|A+Deinit(ClassHandle+h)函数释放动态分配策略中已分配的内存(数组索引)|3304125|3304126|有没有人看到这种方法的任何变化都有任何问题、漏洞、潜在的陷阱或隐藏的好处/缺点？如果我正在重新发明一种设计方法(我想我必须这样做)，你能告诉我它的名字吗？|3304127|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|10|8|@]|9|@]|A|$]]|$1|L|3|-4|5|E|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|E|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|E|7|13|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|15|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|U|$]]

My strategy is:

<ul>
<li>Define all code for the class in a separate file</li>
<li>Define all interfaces for the class in a separate header file</li>
<li>All member functions take a "ClassHandle" which stands in for the instance name (instead of o.foo(), call foo(oHandle)</li>
<li>The constructor is replaced with a function void ClassInit(ClassHandle h, int x, int y,...) OR ClassHandle ClassInit(int x, int y,...) depending on the memory allocation strategy</li>
<li>All member variables are store as a member of a static struct in the class file, encapsulating it in the file, preventing outside files from accessing it</li>
<li>The objects are stored in an array of the static struct above, with predefined handles (visible in the interface) or a fixed limit of objects that can be instantiated</li>
<li>If useful, the class can contain public functions that will loop through the array and call the functions of all the instantiated objects (RunAll() calls each Run(oHandle)</li>
<li>A Deinit(ClassHandle h) function frees the allocated memory (array index) in the dynamic allocation strategy</li>
</ul>

Does anyone see any problems, holes, potential pitfalls or hidden benefits/drawbacks to either variation of this approach? If I am reinventing a design method (and I assume I must be), can you point me to the name of it?

blocks|key|3091318|text|另请参阅this+answer和this+one|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3091319|这是可能的。这在当时看起来总是一个好主意，但后来它变成了维护的噩梦。你的代码变得乱七八糟，到处都是捆绑在一起的代码。如果使用函数指针，新程序员在阅读和理解代码时会遇到很多问题，因为调用了什么函数并不明显。|3091320|使用get/set函数隐藏数据很容易在C中实现，但仅此而已。我在嵌入式环境中看到过多次这样做的尝试，最终这始终是一个维护问题。|3091321|既然你们都准备好了有维护问题，我会避开的。|3091322|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/351733/can-you-write-object-oriented-code-in-c|1|https://stackoverflow.com/questions/415452/object-orientation-in-c^0|4|B|0|G|8|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]|$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|S]]]]

Also see <a href="https://stackoverflow.com/questions/351733/can-you-write-object-oriented-code-in-c">this answer</a> and <a href="https://stackoverflow.com/questions/415452/object-orientation-in-c">this one</a>

It is possible. It always seems like a good idea at the time but afterwards it becomes a maintenance nightmare. Your code become littered with pieces of code tying everything together. A new programmer will have lots of problems reading and understanding the code if you use function pointers since it will not be obvious what functions is called. 

Data hiding with get/set functions is easy to implement in C but stop there. I have seen multiple attempts at this in the embedded environment and in the end it is always a maintenance problem.

Since you all ready have maintenance issues I would steer clear.

blocks|key|329403|text|C接口和实现:创建可重用软件的技术，David+R.Hanson|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|329404|329405|+http://www.informit.com/store/product.aspx?isbn=0201498413|blockquote|329406|329407|329408|这本书很好地回答了你的问题。它是Addison+Wesley专业计算系列的一部分。|329409|基本范例是这样的：|329410|/*+for+data+structure+foo+*/

FOO+*myfoo;
myfoo+=+foo_create(...);
foo_something(myfoo,+...);
myfoo+=+foo_append(myfoo,+...);
foo_delete(myfoo);|code-block|syntax|javascript|329411|entityMap|0|LINK|mutability|MUTABLE|url|http://www.informit.com/store/product.aspx?isbn=0201498413^0|0|E|I|E|0|0|1|1M|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|17|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|18|8|@]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|J|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1E|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1F|8|@]|D|@]|E|$]]|$1|P|3|Q|5|R|7|1G|8|@]|D|@]|E|$S|T]]|$1|U|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

C Interfaces and Implementations: Techniques for Creating Reusable Software, David R. Hanson

<blockquote>
 <a href="http://www.informit.com/store/product.aspx?isbn=0201498413" rel="noreferrer">http://www.informit.com/store/product.aspx?isbn=0201498413</a>
</blockquote>

This book does an excellent job of covering your question. It's in the Addison Wesley Professional Computing series.

The basic paradigm is something like this:

<pre><code>/* for data structure foo */

FOO *myfoo;
myfoo = foo_create(...);
foo_something(myfoo, ...);
myfoo = foo_append(myfoo, ...);
foo_delete(myfoo);
</code></pre>

blocks|key|3304214|text|GTK完全建立在C语言之上，它使用了许多面向对象的概念。我已经通读了GTK的源代码，它给人留下了深刻的印象，而且非常容易阅读。基本概念是每个“类”只是一个结构，以及相关的静态函数。静态函数都接受"instance“结构作为参数，然后执行任何需要的操作，并在必要时返回结果。例如，您可能有一个函数"GetPosition(CircleStruct+obj)“。该函数将简单地挖掘该结构，提取位置编号，可能会构建一个新的PositionStruct对象，将x和y粘贴到新的PositionStruct中，然后返回它。GTK甚至通过在结构中嵌入结构来实现继承。相当聪明。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3304215|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

GTK is built entirely on C and it uses many OOP concepts. I have read through the source code of GTK and it is pretty impressive, and definitely easier to read. The basic concept is that each "class" is simply a struct, and associated static functions. The static functions all accept the "instance" struct as a parameter, do whatever then need, and return results if necessary. For Example, you may have a function "GetPosition(CircleStruct obj)". The function would simply dig through the struct, extract the position numbers, probably build a new PositionStruct object, stick the x and y in the new PositionStruct, and return it. GTK even implements inheritance this way by embedding structs inside structs. pretty clever.

blocks|key|332105|text|#include+<stdio.h>
#include+<math.h>
#include+<string.h>
#include+<uchar.h>

/**
+*+Define+Shape+class
+*/
typedef+struct+Shape+Shape;
struct+Shape+{
++++/**
+++++*+Variables+header...
+++++*/
++++double+width,+height;

++++/**
+++++*+Functions+header...
+++++*/
++++double+(*area)(Shape+*shape);
};

/**
+*+Functions
+*/
double+calc(Shape+*shape)+{
++++++++return+shape->width+*+shape->height;
}

/**
+*+Constructor
+*/
Shape+_Shape()+{
++++Shape+s;

++++s.width+=+1;
++++s.height+=+1;

++++s.area+=+calc;

++++return+s;
}

/********************************************/

int+main()+{
++++Shape+s1+=+_Shape();
++++s1.width+=+5.35;
++++s1.height+=+12.5462;

++++printf("Hello+World\n\n");

++++printf("User.width+=+%25f\n",+s1.width);
++++printf("User.height+=+%25f\n",+s1.height);
++++printf("User.area+=+%25f\n\n",+s1.area(&s1));

++++printf("Made+with+\xe2\x99\xa5+\n");

++++return+0;
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|332106|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;string.h&gt;
#include &lt;uchar.h&gt;

/**
 * Define Shape class
 */
typedef struct Shape Shape;
struct Shape {
 /**
 * Variables header...
 */
 double width, height;

 /**
 * Functions header...
 */
 double (*area)(Shape *shape);
};

/**
 * Functions
 */
double calc(Shape *shape) {
 return shape-&gt;width * shape-&gt;height;
}

/**
 * Constructor
 */
Shape _Shape() {
 Shape s;

 s.width = 1;
 s.height = 1;

 s.area = calc;

 return s;
}

/********************************************/

int main() {
 Shape s1 = _Shape();
 s1.width = 5.35;
 s1.height = 12.5462;

 printf("Hello World\n\n");

 printf("User.width = %f\n", s1.width);
 printf("User.height = %f\n", s1.height);
 printf("User.area = %f\n\n", s1.area(&amp;s1));

 printf("Made with \xe2\x99\xa5 \n");

 return 0;
};
</code></pre>

blocks|key|332115|text|我将给出一个简单的例子，说明如何用C语言实现OOP。我知道这篇文章来自2009年，但我还是想补充一下。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|332116|///+Object.h
typedef+struct+Object+{
++++uuid_t+uuid;
}+Object;

int+Object_init(Object+*self);
uuid_t+Object_get_uuid(Object+*self);
int+Object_clean(Object+*self);

///+Person.h
typedef+struct+Person+{
++++Object+obj;
++++char+*name;
}+Person;

int+Person_init(Person+*self,+char+*name);
int+Person_greet(Person+*self);
int+Person_clean(Person+*self);

///+Object.c
#include+"object.h"

int+Object_init(Object+*self)
{
++++self->uuid+=+uuid_new();

++++return+0;
}
uuid_t+Object_get_uuid(Object+*self)
{+//+Don't+actually+create+getters+in+C...
++++return+self->uuid;
}
int+Object_clean(Object+*self)
{
++++uuid_free(self->uuid);

++++return+0;
}

///+Person.c
#include+"person.h"

int+Person_init(Person+*self,+char+*name)
{
++++Object_init(&self->obj);+//+Or+just+Object_init(&self);
++++self->name+=+strdup(name);

++++return+0;
}
int+Person_greet(Person+*self)
{
++++printf("Hello,+%25s",+self->name);

++++return+0;
}
int+Person_clean(Person+*self)
{
++++free(self->name);
++++Object_clean(self);

++++return+0;
}

///+main.c
int+main(void)
{
++++Person+p;

++++Person_init(&p,+"John");
++++Person_greet(&p);
++++Object_get_uuid(&p);+//+Inherited+function
++++Person_clean(&p);

++++return+0;
}|code-block|syntax|javascript|332117|基本概念包括将“继承类”放在结构的顶部。这样，访问结构中的前4个字节也会访问“继承类”中的前4个字节(Asuming非疯狂优化)。现在，当结构的指针被强制转换为“继承类”时，“继承类”可以像正常访问其成员一样访问“继承值”。|332118|这和一些构造函数、析构函数、分配函数和事务函数的命名约定(我建议使用init、clean、new、free)将会让你大有作为。|332119|对于虚函数，可以在结构中使用函数指针，也可以使用Class_func(...)；包装器。对于(简单的)模板，添加一个类参数来确定大小，需要一个空*指针，或者需要一个只具有你所关心的功能的“size_t”类型。(例如，int+GetUUID(对象*自身)；GetUUID(&p);)|332120|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I will give a simple example of how OOP should be done in C. I realise this thead is from 2009 but would like to add this anyway.

<pre><code>/// Object.h
typedef struct Object {
 uuid_t uuid;
} Object;

int Object_init(Object *self);
uuid_t Object_get_uuid(Object *self);
int Object_clean(Object *self);

/// Person.h
typedef struct Person {
 Object obj;
 char *name;
} Person;

int Person_init(Person *self, char *name);
int Person_greet(Person *self);
int Person_clean(Person *self);

/// Object.c
#include "object.h"

int Object_init(Object *self)
{
 self-&gt;uuid = uuid_new();

 return 0;
}
uuid_t Object_get_uuid(Object *self)
{ // Don't actually create getters in C...
 return self-&gt;uuid;
}
int Object_clean(Object *self)
{
 uuid_free(self-&gt;uuid);

 return 0;
}

/// Person.c
#include "person.h"

int Person_init(Person *self, char *name)
{
 Object_init(&amp;self-&gt;obj); // Or just Object_init(&amp;self);
 self-&gt;name = strdup(name);

 return 0;
}
int Person_greet(Person *self)
{
 printf("Hello, %s", self-&gt;name);

 return 0;
}
int Person_clean(Person *self)
{
 free(self-&gt;name);
 Object_clean(self);

 return 0;
}

/// main.c
int main(void)
{
 Person p;

 Person_init(&amp;p, "John");
 Person_greet(&amp;p);
 Object_get_uuid(&amp;p); // Inherited function
 Person_clean(&amp;p);

 return 0;
}
</code></pre>

The basic concept involves placing the 'inherited class' at the top of the struct. This way, accessing the first 4 bytes in the struct also accesses the first 4 bytes in the 'inherited class' (Asuming non-crazy optimalisations). Now, when the pointer of the struct is cast to the 'inherited class', the 'inherited class' can access the 'inherited values' in the same way it would access it's members normally.

This and some naming conventions for constructors, destructors, allocation and deallocarion functions (I recommend init, clean, new, free) will get you a long way.

As for Virtual functions, use function pointers in the struct, possibly with Class_func(...); wrapper too.
As for (simple) templates, add a size_t parameter to determine size, require a void* pointer, or require a 'class' type with just the functionality you care about. (e.g. int GetUUID(Object *self); GetUUID(&amp;p);)

Assuming I have to use C (no C++ or object oriented compilers) and I don't have dynamic memory allocation, what are some techniques I can use to implement a class, or a good approximation of a class? Is it always a good idea to isolate the "class" to a separate file? Assume that we can preallocate the memory by assuming a fixed number of instances, or even defining the reference to each object as a constant before compile time. Feel free to make assumptions about which OOP concept I will need to implement (it will vary) and suggest the best method for each.

Restrictions:

<ul>
<li>I have to use C and not an OOP
because I'm writing code for an
embedded system, and the compiler and
preexisting code base is in C. </li>
<li>There is no dynamic memory allocation
because we don't have enough memory
to reasonably assume we won't run out
if we start dynamically allocating
it.</li>
<li>The compilers we work with have no problems with function pointers</li>
</ul>

How do you implement a class in C?

嵌入式系统

对象存储

编译器

假设我必须使用C(没有C++或面向对象的编译器)，并且我没有动态内存分配，那么我可以使用哪些技术来实现一个类，或者一个类的一个很好的近似值？将“类”隔离到一个单独的文件中总是一个好主意吗？假设我们可以通过假设固定数量的实例，或者甚至在编译前将对每个对象的引用定义为常量来预先分配内存。请随意假设我需要实现哪个OOP概念(...

问如何在C中实现一个类？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C中实现一个类？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C中实现一个类？
EN