C++ 对象工厂，而不是C++；

我把一组代码从C++转换成C。在一个对象工厂中有一个等价的C模式吗？ 考虑以下源代码。基于参数（

int-type

）的

ObjectFactory

（）函数应返回指向pedicure类型结构的空指针。我如何实例化结构，使其在函数返回后有一个指向它的指针

typedef struct {
    unsigned int a; 
    unsigned int b; 
    unsigned int c; 
} CThings ; 

typedef struct {
    unsigned int d; 
    unsigned int e; 
    unsigned int f; 
} CPlaces ; 

void * ObjectFactory( int type ) {

    switch( type ) {
        case 5 : {          
            return ??? CPlaces ; 
            break; 
        }
        case 35 : {         
            return ??? CThings ; 
            break; 
        }
        default: {
            // unknown type 
            return NULL ; 
        }
    }

    return NULL ; 
}



int _tmain(int argc, _TCHAR* argv[])
{
    void * p = ObjectFactory( 5 ); 

    // Do soemthing with the pointer. 
    CPlaces * places = (CPlaces*) p ; 

    places->d = 5 ; 
    places->e = 6 ; 
    places->f = 7 ; 


    return 0;
}

---

使用malloc怎么样

case 5: return malloc(sizeof(struct CPlaces));

如果您已经返回，则无需中断。如果愿意，可以在返回之前添加一些初始化

---

调用者必须知道实际的类型，这样她才能将指针转换回正确的类型。这可能相当于调用方站点上的一个重复switch语句。

使用

malloc

如何：

case 5: return malloc(sizeof(struct CPlaces));

#include <stdlib.h>

typedef enum enum_ObjectType {
    CPlaces_Object = 5,
    CThings_Object = 35,
} ObjectType;

typedef struct struct_CThings {
    unsigned int a;
    unsigned int b;
    unsigned int c;
} CThings;

typedef struct struct_CPlaces {
    unsigned int d;
    unsigned int e;
    unsigned int f;
} CPlaces ;

void *ObjectFactory(ObjectType type) {
    switch( type ) {
        case CPlaces_Object: {
            return malloc(sizeof(CPlaces));
            break;
        }
        case CThings_Object: {
            return malloc(sizeof(CThings));
            break;
        }
        default: { /* unknown type */
            return NULL;
        }
    }
    return NULL;
}

int main(void) {
    CPlaces *places = ObjectFactory(CPlaces_Object);
    CThings *things = ObjectFactory(CThings_Object);

    things->a = 2;
    things->b = 8;
    things->c = 4;

    places->d = 5;
    places->e = 7;
    places->f = 3;

    return 0;
}

如果您已经返回，则无需中断。如果愿意，可以在返回之前添加一些初始化

调用者必须知道实际的类型，这样她才能将指针转换回正确的类型。这可能相当于调用方站点上的一个重复switch语句。

\include
#include <stdlib.h>

typedef enum enum_ObjectType {
    CPlaces_Object = 5,
    CThings_Object = 35,
} ObjectType;

typedef struct struct_CThings {
    unsigned int a;
    unsigned int b;
    unsigned int c;
} CThings;

typedef struct struct_CPlaces {
    unsigned int d;
    unsigned int e;
    unsigned int f;
} CPlaces ;

void *ObjectFactory(ObjectType type) {
    switch( type ) {
        case CPlaces_Object: {
            return malloc(sizeof(CPlaces));
            break;
        }
        case CThings_Object: {
            return malloc(sizeof(CThings));
            break;
        }
        default: { /* unknown type */
            return NULL;
        }
    }
    return NULL;
}

int main(void) {
    CPlaces *places = ObjectFactory(CPlaces_Object);
    CThings *things = ObjectFactory(CThings_Object);

    things->a = 2;
    things->b = 8;
    things->c = 4;

    places->d = 5;
    places->e = 7;
    places->f = 3;

    return 0;
}

typedef枚举枚举对象类型{
CPlaces_Object=5，
CThings_Object=35，
}对象类型；
类型定义结构类型{
无符号整数a；
无符号整数b；
无符号整数c；
}CThings；
typedef struct_CPlaces{
无符号整数d；
无符号整数e；
无符号整数f；
}CPlaces；
void*ObjectFactory（ObjectType类型）{
开关（类型）{
案例CPlaces_对象：{
返回malloc（sizeof（CPlaces））；
打破
}
案例内容\u对象：{
返回malloc（sizeof（CThings））；
打破
}
默认值：{/*未知类型*/
返回NULL；
}
}
返回NULL；
}
内部主（空）{
CPlaces*places=ObjectFactory（CPlaces\u对象）；
CThings*things=ObjectFactory（CThings\u对象）；
事物->a=2；
事物->b=8；
事物->c=4；
地点->d=5；
地点->e=7；
地点->f=3；
返回0；
}

#包括
typedef枚举枚举对象类型{
CPlaces_Object=5，
CThings_Object=35，
}对象类型；
类型定义结构类型{
无符号整数a；
无符号整数b；
无符号整数c；
}CThings；
typedef struct_CPlaces{
无符号整数d；
无符号整数e；
无符号整数f；
}CPlaces；
void*ObjectFactory（ObjectType类型）{
开关（类型）{
案例CPlaces_对象：{
返回malloc（sizeof（CPlaces））；
打破
}
案例内容\u对象：{
返回malloc（sizeof（CThings））；
打破
}
默认值：{/*未知类型*/
返回NULL；
}
}
返回NULL；
}
内部主（空）{
CPlaces*places=ObjectFactory（CPlaces\u对象）；
CThings*things=ObjectFactory（CThings\u对象）；
事物->a=2；
事物->b=8；
事物->c=4；
地点->d=5；
地点->e=7；
地点->f=3；
返回0；
}
这将C++翻译成C，乍一看是一种特别愚蠢的练习。你会解释一下你为什么从事这样一个看似毫无意义的活动吗？@ AlfpStnbAc+ 1：你曾经写过的最好的评论。“嘘，鸭子，你不能那样做，就像我在我的问题中所说的，这不是C++，如果C是命令式编程，为什么还要使用术语
object
language@Itsik：面向对象并不排除语言中的命令式样式。C++当然不是声明式的，尽管它是面向对象的。（尽管你当然是正确的，C中没有对象）这一点，把C++翻译成C，乍一看似乎是一种特别愚蠢的练习。你会解释一下你为什么从事这样一个看似毫无意义的活动吗？@ AlfpStnbAc+ 1：你曾经写过的最好的评论。“嘘，鸭子，你不能那样做，就像我在我的问题中所说的，这不是C++，如果C是命令式编程，为什么还要使用术语
object
language@Itsik：面向对象并不排除语言中的命令式样式。C++当然不是声明式的，尽管它是面向对象的。（虽然你是正确的；C中没有对象）不幸的是，这并不等同于C++对象工厂。我希望我的对象被初始化为垃圾以外的东西。我建议使用varargs参数，并使用“构造函数”函数包装malloc和初始化。这些构造函数可以重载以获取varargs，并在解包varargs后调用“真实”构造函数。请不要乱动varargs。如果类型确实相关，并且为它们创建一个工厂也是合理的，那么从逻辑上讲，我们应该期望能够使用一组通用的参数来构造它们中的任何一个。我的意思是，使用varargs，我们基本上需要知道将要传递哪个构造函数，这意味着我们必须知道要创建的是哪种类型，所以我们最好直接创建它。@Michael Price，如果你不想随机垃圾调用calloc而不是malloc；D@AngelO'Sphere calloc仍然没有将我的“成员”初始化为我想要的状态。如果目标是在C++中模拟C++对象，那么这是必须的。C中的OOP不是不可能的，它只是非常冗长。@MichaelPrice从技术上讲，没有什么可以阻止您在返回结构之前指定一个函数来初始化结构。但是，正如你所说的，在C中实现类机器需要大量的繁琐工作。不幸的是，这并不等同于C++对象工厂。我希望我的对象被初始化为垃圾以外的东西。我建议使用varargs参数，并使用“构造函数”函数包装malloc和初始化。这些构造函数可以重载以获取varargs并在解压缩varargs后调用“real”构造函数