你如何在 C 中实现一个类？ [关闭]

Question

假设我必须使用 C（没有 C++ 或面向对象的编译器）并且我没有动态内存分配，我可以使用哪些技术来实现类或类的良好近似？将“类”隔离到单独的文件中总是一个好主意吗？假设我们可以通过假设固定数量的实例来预分配内存，甚至可以在编译时将每个对象的引用定义为常量。随意对我需要实现的 OOP 概念做出假设（它会有所不同），并为每个概念提出最佳方法。

限制：

• 我必须使用 C 而不是 OOP 因为我正在为一个 嵌入式系统，以及编译器和 预先存在的代码库是 C 语言。
• 没有动态内存分配 因为我们没有足够的内存 合理地假设我们不会用完 如果我们开始动态分配 它。
• 我们使用的编译器在函数指针方面没有问题

Answer 1

这取决于您想要拥有的确切“面向对象”功能集。如果您需要重载和/或虚拟方法之类的东西，您可能需要在结构中包含函数指针：

typedef struct {
  float (*computeArea)(const ShapeClass *shape);
} ShapeClass;

float shape_computeArea(const ShapeClass *shape)
{
  return shape->computeArea(shape);
}

这将让您通过“继承”基类并实现合适的功能来实现一个类：

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;
}

这当然需要您还实现一个构造函数，以确保正确设置函数指针。通常你会为实例动态分配内存，但你也可以让调用者这样做：

void rectangle_new(RectangleClass *rect)
{
  rect->width = rect->height = 0.f;
  rect->shape.computeArea = rectangle_computeArea;
}

如果你想要几个不同的构造函数，你将不得不“装饰”函数名，你不能有多个rectangle_new()函数：

void rectangle_new_with_lengths(RectangleClass *rect, float width, float height)
{
  rectangle_new(rect);
  rect->width = width;
  rect->height = height;
}

这是一个显示用法的基本示例：

int main(void)
{
  RectangleClass r1;

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

我希望这至少能给你一些想法。要获得成功且丰富的 C 面向对象框架，请查看 glib 的 GObject 库。

另外请注意，上面没有明确的“类”建模，每个对象都有自己的方法指针，这比您通常在 C++ 中找到的要灵活一些。此外，它会消耗内存。您可以通过将方法指针填充到 class 结构中来摆脱这种情况，并为每个对象实例发明一种方法来引用一个类。

Answer 2

我也必须做一次家庭作业。我遵循了这种方法：

1. 在一个 结构。
2. 定义你的函数成员 将指向您的结构的指针作为 第一个参数。
3. 在一个标题和一个 c 中执行这些操作。 结构定义的标头 & 函数声明，c for 实现。

一个简单的例子是这样的：

/// Queue.h
struct Queue
{
    /// members
}
typedef struct Queue Queue;

void push(Queue* q, int element);
void pop(Queue* q);
// etc.
/// 

Answer 3

如果您只想要一个类，请使用structs 的数组作为“对象”数据并将指向它们的指针传递给“成员”函数。您可以在声明 struct _whatever 之前使用 typedef struct _whatever Whatever 来隐藏客户端代码的实现。这样的“对象”和 C 标准库 FILE 对象没有区别。

如果您想要多个具有继承和虚函数的类，那么通常将指向函数的指针作为结构的成员，或指向虚函数表的共享指针。 GObject 库同时使用了 this 和 typedef 技巧，并且被广泛使用。

还有一本关于此技术的在线书籍 - Object Oriented Programming with ANSI C。

Answer 4

C 接口和实现：创建可重用软件的技术，David R. Hanson

http://www.informit.com/store/product.aspx?isbn=0201498413

这本书很好地解决了您的问题。它在 Addison Wesley 专业计算系列中。

基本范式是这样的：

/* for data structure foo */

FOO *myfoo;
myfoo = foo_create(...);
foo_something(myfoo, ...);
myfoo = foo_append(myfoo, ...);
foo_delete(myfoo);

Answer 5

你可以看看 GOBject。它是一个 OS 库，可为您提供执行对象的详细方法。

http://library.gnome.org/devel/gobject/stable/

Answer 6

我将举一个简单的例子来说明如何在 C 中完成 OOP。我知道这个主题是 2009 年的，但还是想添加它。

/// 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, %s", 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;
}

基本概念包括将“继承的类”放在结构的顶部。这样，访问结构中的前 4 个字节也会访问“继承类”中的前 4 个字节（假设非疯狂优化）。现在，当结构的指针被强制转换为“继承的类”时，“继承的类”可以访问“继承的值”，就像它正常访问它的成员一样。

这个和一些构造函数、析构函数、分配和deallocarion函数的命名约定（我推荐init、clean、new、free）会让你走得很远。

对于虚函数，在结构体中使用函数指针，可能使用 Class_func(...);包装也是。 至于（简单）模板，添加一个 size_t 参数来确定大小，需要一个 void* 指针，或者需要一个只具有您关心的功能的“类”类型。 （例如 int GetUUID(Object *self); GetUUID(&p);)

Answer 7

使用struct 模拟类的数据成员。在方法范围方面，您可以通过将 private 函数原型放在 .c 文件中并将 public 函数放在 .h 文件中来模拟私有方法。

Answer 8

#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 = %f\n", s1.width);
    printf("User.height = %f\n", s1.height);
    printf("User.area = %f\n\n", s1.area(&s1));

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

    return 0;
};

Answer 9

在您的情况下，该类的良好近似值可能是ADT。但还是不一样。

Answer 10

我的策略是：

• 在单独的文件中定义类的所有代码
• 在单独的头文件中定义类的所有接口
• 所有成员函数都采用代表实例名称的“ClassHandle”（而不是 o.foo()，调用 foo(oHandle)
• 构造函数替换为函数 void ClassInit(ClassHandle h, int x, int y,...) 或 ClassHandle ClassInit(int x, int y,...) 取决于内存分配策略
• 所有成员变量都作为静态结构的成员存储在类文件中，将其封装在文件中，防止外部文件访问它
• 对象存储在上述静态结构的数组中，具有预定义的句柄（在界面中可见）或可以实例化的对象的固定限制
• 如果有用，该类可以包含公共函数，这些函数将遍历数组并调用所有实例化对象的函数（RunAll() 调用每个 Run(oHandle)
• Deinit(ClassHandle h) 函数在动态分配策略中释放分配的内存（数组索引）

是否有人看到这种方法的任何一种变体存在任何问题、漏洞、潜在陷阱或隐藏的好处/缺点？如果我正在重新发明一种设计方法（我认为我必须这样做），你能指出它的名称吗？

Answer 11

另见this answer和this one

这是可能的。这在当时似乎总是一个好主意，但后来它变成了维护的噩梦。您的代码中到处都是将所有内容联系在一起的代码。如果您使用函数指针，新程序员在阅读和理解代码时会遇到很多问题，因为调用什么函数并不明显。

使用 get/set 函数进行数据隐藏很容易在 C 中实现，但仅止于此。我已经在嵌入式环境中看到过多次尝试，最终它始终是一个维护问题。

既然你们都准备好了维护问题，我会避开。

Answer 12

GTK 完全建立在 C 之上，它使用了许多 OOP 概念。我通读了 GTK 的源代码，它给人留下了深刻的印象，而且绝对更容易阅读。基本概念是每个“类”只是一个结构和相关的静态函数。静态函数都接受“实例”结构作为参数，然后做任何需要的事情，并在必要时返回结果。例如，您可能有一个函数“GetPosition(CircleStruct obj)”。该函数将简单地挖掘结构，提取位置编号，可能构建一个新的 PositionStruct 对象，将 x 和 y 粘贴到新的 PositionStruct 中，然后返回它。 GTK 甚至通过在结构中嵌入结构来实现继承。很聪明。

Answer 13

我的方法是将struct 和所有主要关联的 函数移到单独的源文件中，以便可以“便携”地使用它。

根据您的编译器，您可能可以将函数包含到 struct 中，但这是一个 非常 特定于编译器的扩展，与我经常使用的标准的最后一个版本:)

Answer 14

第一个 c++ 编译器实际上是将 C++ 代码翻译成 C 的预处理器。

所以很有可能在 C 中创建类。 您可以尝试挖掘一个旧的 C++ 预处理器，看看它会创建什么样的解决方案。

Answer 15

你想要虚拟方法吗？

如果不是，那么您只需在结构本身中定义一组函数指针。如果您将所有函数指针分配给标准 C 函数，那么您将能够以与在 C++ 下的语法非常相似的语法从 C 中调用函数。

如果你想拥有虚拟方法，它会变得更加复杂。基本上，您需要为每个结构实现自己的 VTable，并根据调用的函数将函数指针分配给 VTable。然后，您将需要结构本身中的一组函数指针，这些指针又调用 VTable 中的函数指针。这本质上就是 C++ 所做的。

TBH 但是...如果您想要后者，那么您最好找到一个可以使用的 C++ 编译器并重新编译该项目。我从来没有理解过对 C++ 不能在嵌入式中使用的痴迷。我已经用过很多次了，它的工作速度很快，而且没有内存问题。当然，你必须对你所做的事情更加小心，但实际上并没有那么复杂。

Answer 16

C 不是 OOP 语言，正如您正确指出的那样，因此没有内置的方法来编写真正的类。最好的办法是查看structs 和function pointers，这些可以让你建立一个类的近似值。但是，由于 C 是过程性的，您可能需要考虑编写更多类似 C 的代码（即不尝试使用类）。

另外，如果你会使用 C，你可能会使用 C++ 并获取类。