每当我看到 C 语言中的“类”（指任何结构体，通过访问以它为第一个参数的指针作为参数的函数来使用）时，我会看到它们是这样实现的：
typedef struct
{
int member_a;
float member_b;
} CClass;
CClass* CClass_create();
void CClass_destroy(CClass *self);
void CClass_someFunction(CClass *self, ...);
...
在这种情况下，CClass_create 总是使用 malloc 分配内存并返回指针。
每当我看到 C++ 中不必要地出现 new 时，它通常似乎会让 C++ 程序员发疯，但这种做法在 C 中是可接受的。为什么堆分配的结构体“类”如此常见？
这其中有几个原因：
让我们简要地讨论它们。
对于不透明指针，它使您可以执行类似以下的操作：
struct CClass_;
typedef struct CClass_ CClass;
// the rest as in your example
struct CClass_的定义，使其与它的更改隔离开来，并启用其他有趣的功能，例如为不同平台实现类的不同方式。CClass的堆叠变量。但是，另一方面，人们可以看到这并不禁止静态分配CClass对象（从某个池返回）-由CClass_create或者像CClass_create_static这样的另一个函数返回。
缺乏析构函数 - 由于C编译器不会自动销毁您的CClass堆栈对象，因此您需要自己进行处理（手动调用析构函数）。因此，唯一剩下的好处是堆栈分配通常比堆分配更快。另一方面，您不必使用堆 - 您可以从池、竞技场或类似的地方进行分配，这可能几乎与堆栈分配一样快，而且没有下面讨论的堆栈分配的潜在问题。
嵌入式系统 - 堆栈不是“无限”的资源，您知道。当然，在今天的“常规”操作系统（POSIX、Windows等）上大多数应用程序几乎是如此。但是，在嵌入式系统上，堆栈可能只有几 KB。这很极端，但即使是“大型”嵌入式系统的堆栈也在MB范围内。因此，如果过度使用，它将耗尽。当它这样做时，大多数情况下没有保证会发生什么 - 就我所知，在C和C++中都是“未定义行为”。另一方面，当内存不足时，CClass_create()可以返回空指针，您可以处理它。
容器 - C++用户喜欢堆栈分配，但是，如果您在堆栈上创建一个std::vector，它的内容将被分配到堆上。当然，您可以进行调整，但这是默认行为，说“容器的所有成员都是堆分配的”会使人们更容易处理，而不是试图弄清楚如何处理空间不足的情况。
惯性 - 嗯，OO来自SmallTalk。那里一切都是动态的，所以，“自然”的翻译成C的方式是“把所有东西都放在堆上”。因此，最初的示例就是这样的，并在许多年后启发了其他人。CClass CClass_make();
void CClass_deinit(CClass *me);
但是，如果你想同时允许堆栈和堆，你需要添加：
CClass *CClass_create();
void CClass_destroy(CClass *me);
对于实施者来说，这意味着更多的工作，但对用户来说也很困惑。虽然可以创建略有不同的接口，但这并不能改变你需要两组函数的事实。
当然，“容器”原因部分上也是“懒惰”的原因。
make/deinit 范式并不一定强制你将对象保留在堆栈上 - 它只是意味着调用者负责分配/释放内存，无论是堆栈还是堆。你可以这样做：CClass *p = malloc(...); *p = CClass_make(); ...; CClass_deinit(p); free(p);。 - Nate Eldredge假设您的问题中，CClass_create和CClass_destroy使用malloc/free，那么对我而言，以下操作是不好的实践：
void Myfunc()
{
CClass* myinstance = CClass_create();
...
CClass_destroy(myinstance);
}
因为我们可以轻松地避免使用 malloc 和 free：
void Myfunc()
{
CClass myinstance; // no malloc needed here, myinstance is on the stack
CClass_Initialize(&myinstance);
...
CClass_Uninitialize(&myinstance);
// no free needed here because myinstance is on the stack
}
使用
CClass* CClass_create()
{
CClass *self= malloc(sizeof(CClass));
CClass_Initialize(self);
return self;
}
void CClass_destroy(CClass *self);
{
CClass_Uninitialize(self);
free(self);
}
void CClass_Initialize(CClass *self)
{
// initialize stuff
...
}
void CClass_Uninitialize(CClass *self);
{
// uninitialize stuff
...
}
在C++中，我们更愿意这样做：
void Myfunc()
{
CClass myinstance;
...
}
比这更：
void Myfunc()
{
CClass* myinstance = new CCLass;
...
delete myinstance;
}
new/delete。在C语言中，当某个组件提供了“create”函数时，组件实现者也控制组件如何初始化。因此，它不仅模拟了C++的operator new，还模拟了类构造函数。
放弃这种对初始化的控制意味着需要更多的输入错误检查，因此保持控制使得提供一致和可预测的行为更加容易。
我也不同意malloc总是被用来分配内存。尽管这经常是情况，但并非总是如此。例如，在某些嵌入式系统中，根本不使用malloc/free。而X_create函数可以使用其他方式进行分配，例如从在编译时大小固定的数组中分配。
private在c++中得以解决。但是您的class的定义仍会被所有使用它的编译单元导入，这使得即使只有private成员更改，也需要重新编译它们。c++中常用的解决方法是pimpl模式：在实现文件中仅定义所有私有成员的第二个struct（或：class）。当然，这需要在堆上分配您的pimpl。
此外，现代面向对象编程语言（例如 java 或 c#）有一些方法来分配对象（通常会内部决定是堆栈还是堆），而不需要调用代码知道它们的定义。
int[]和一个内部使用的结构类型，其中包含实际数据。客户端代码仍然需要知道结构的大小，但内部细节将被屏蔽。然而，我不知道有什么方法可以在不需要标准规定的行为的情况下实现这一点，而且今天的一些编译器试图“优化掉”标准没有要求保留的任何内容。 - supercatint []，因为在C99和Strict Aliasing规则出现之前的1990年代存在对齐问题。然而，除非客户端代码实际上将数组用作访问底层结构的手段，否则我认为结构体中数组的类型并不重要。此外，如果构建系统能够识别到在不同的翻译单元中声明了不同的结构，则根据C标准它就没有任何义务；如果它不能识别到，那么它可能无法... - supercatmalloc 的开销比现在更加重要的日子里。 - user2371524*并不意味着它已经被malloc分配了内存。你可能得到的是指向static全局变量的指针；在你的情况下，确实，CClass_destroy()不需要任何参数，这表明它已经知道要销毁的对象的某些信息。malloc）是唯一允许修改对象的方式。void CClass_create(CClass*)。CClass_create() 即可。{
CClass stk;
CClass_create(&stk);
CClass *dyn = malloc(sizeof(CClass));
CClass_create(dyn);
CClass_destroy(&stk); // the local object lifetime ends here, dyn lives on
}
// and later, assuming you kept track of dyn
CClass_destroy(dyn); // destructed
free(dyn); // deleted
请注意不要返回指向本地变量（分配在堆栈上）的引用，因为那是未定义行为。
无论你如何分配内存，都需要在正确的时机调用void CClass_destroy(CClass*);（即该对象生命周期的结束），如果是动态分配的，则还需要释放该内存。
区分分配/释放和构造/析构，它们并不相同（即使在C++中它们可能会自动耦合在一起）。
C语言缺少C++程序员所熟知的一些东西，即：
这种方法的主要优点是可以在C文件中隐藏结构体，并通过创建和销毁函数强制正确的构造和析构。
如果在.h文件中暴露结构体，则意味着用户可以直接访问成员，这会破坏封装性。同时，不强制创建会导致对象的错误构造。
malloc分配的内存。 - Giorgi Moniava你的问题是：“为什么在C中动态分配内存很常见，而在C++中不是？”
C++有很多构造函数可以使new变得冗余。 复制、移动和普通构造函数、析构函数、标准库、分配器。
但在C中，你无法绕过动态分配内存。
malloc/free支持，假设它们是这样的想法是一个大错误。它们可能很容易地使用和栈分配一样快速的东西。 - Alex Celeste