在c中的结构内声明变量

我想为我的编程语言制作一个面向对象的预处理器，将我的语言转换成C（就像早期的C++）。我想用结构来模拟类。问题是：如何在结构中声明变量，如下所示：

typedef struct { //equivalent of class
   int a = 5;
   int (*sub)(int) = &int_sub; //function of a class, uses an external declared function
} class_name;

我尝试了上面的代码，但编译器编写了以下代码：

error: expected ‘:’, ‘,’, ‘;’, ‘}’ or ‘__attribute__’ before ‘=’ token 
       void (*sub)(int) = &int_sub;

我有两个问题：

我可以在结构中声明变量吗

如果是，如何进行

---

不能在结构定义中指定指针值。您可以使用函数初始化它

typedef struct { //equivalent of class
   int a;
   int (*sub)(int);
} class_name;

int int_sub (int a)
{
   // your stuff
   return 0;
}

int main()
{
   class_name myClassVariable;

   myClassVariable.a = 5;
   myClassVariable.sub = int_sub;

   printf("class_name.a = %d\n", myClassVariable.a );
   printf("class_name.sub = %p\n", myClassVariable.sub );
   printf("int_sub address = %p\n", int_sub );

   return 0;
}

或者，如artm答案所示，您可以初始化分配的变量：

class_name my_struct = { .a = 5, .sub = int_sub };

---

或者，也可以初始化结构类型的变量

int func( int a ){}

typedef struct {
    int a;
    int (*sub)(int);
} class_name;

class_name my_struct = { .a = 5, .sub = func };

---

我认为您的问题不是如何声明，而是如何初始化结构成员

在h文件中将类定义为不透明类型。对函数指针使用

typedef

h文件

// opaque type declaration
typedef struct class_name class_name;

// types used by this class
typedef int sub_func_t (int);

// member functions of the class
class_name* class_init (int a, sub_func_t* sub);

然后从其构造函数内部初始化它：

c文件

struct class_name { //equivalent of class
   int a;
   sub_func_t* sub;
};

class_name* class_init (int a, sub_func_t* sub) 
{ 
  class_name* new_class = malloc(sizeof(*new_class)); 
  assert(new_class != NULL);
  *new_class = (class_name){a, sub};
  return new_class; 
}

---

您正在发明自己的编程语言，但不知道如何声明结构？嗯……：）无论如何，这里您应该问的第一个问题是：您的类在内部使用外部定义的函数有什么意义？这是某种函子吗？那不是真的。还可以使用简单的初始值设定项来初始化结构。不需要任何功能。@fuzzxl您说得对。我将进行编辑。最好您应该使用不透明类型实现类，这样您在main中如何初始化结构就不太相关了，因为您首先不应该这样做-这是糟糕的OOP。相反，它应该从不透明类型的构造函数内部初始化。例如

class\u name*class\u init（inta）{class\u name*new\u class=malloc（sizeof（*new\u class））；new\u class->a=a；new\u class->sub=您可能想要这里的静态函数；返回new\u class；}

@Lundin好答案+1。和我通常做的一样。我认为OP水平有点低，将讨论转移到指针和不透明的类型。“伦丁”我想知道，有多少OOP狂热者会考虑初始化包括分配；这也是糟糕的OOP（实际上，它在技术上不符合OOP）。我倾向于选择更受

memcpy

启发的东西，例如

T*T_init（T*destination，T source）{return destination？memcpy（destination，&source，sizeof source）：NULL；}

，因为这允许调用者选择最合适的分配形式：）