Construtor predefinido em C

C++ é diferente de C neste caso no que diz respeito a não ter "classes". No entanto, C (como muitas outras linguagens) ainda pode ser usado para programação orientada a objetos. Neste caso, seu construtor pode ser uma função que inicializa uma estrutura. Isto é o mesmo que Construtores (apenas uma sintaxe diferente). Outra diferença é que você tem que alocar o objeto usando malloc() (ou alguma variante). Em C++, você simlpy usaria o operador 'novo'.

Por exemplo, C++ código:

class A {
  public:
    A() { a = 0; }
    int a;
};

int main() 
{
  A b;
  A *c = new A;
  return 0;
}

Código C equivalente:

struct A {
  int a;
};

void init_A_types(struct A* t)
{
   t->a = 0;
}

int main()
{
   struct A b;
   struct A *c = malloc(sizeof(struct A));
   init_A_types(&b);
   init_A_types(c);
   return 0;
}

A função 'init_A_types' como um construtor faria em C++.

Você cria dois ficheiros header. Um é o arquivo de cabeçalho "público" usado pelos clientes do seu código. Contém definições como esta:

typedef struct t_ProcessStruct *t_ProcessHandle;

extern t_ProcessHandle NewProcess();
extern void DisposeProcess(t_ProcessHandle handle);

typedef struct t_PermissionsStruct *t_PermissionsHandle;

extern t_PermissionsHandle NewPermissions();
extern void DisposePermissions(t_PermissionsHandle handle);

extern void SetProcessPermissions(t_ProcessHandle proc, t_PermissionsHandle perm);

Depois cria um ficheiro de cabeçalho privado que contém definições como esta:

typedef void (*fDisposeFunction)(void *memoryBlock);

typedef struct {
    fDisposeFunction _dispose;
} t_DisposableStruct;

typedef struct {
    t_DisposableStruct_disposer; /* must be first */
    PID _pid;
    /* etc */
} t_ProcessStruct;

typedef struct {
    t_DisposableStruct_disposer; /* must be first */
    PERM_FLAGS _flags;
    /* etc */
} t_PermissionsStruct;

E depois em sua implementação você pode fazer algo assim:

static void DisposeMallocBlock(void *process) { if (process) free(process); }

static void *NewMallocedDisposer(size_t size)
{
    assert(size > sizeof(t_DisposableStruct);
    t_DisposableStruct *disp = (t_DisposableStruct *)malloc(size);
    if (disp) {
       disp->_dispose = DisposeMallocBlock;
    }
    return disp;
}

static void DisposeUsingDisposer(t_DisposableStruct *ds)
{
    assert(ds);
    ds->_dispose(ds);
}

t_ProcessHandle NewProcess()
{
    t_ProcessHandle proc =  (t_ProcessHandle)NewMallocedDisposer(sizeof(t_ProcessStruct));
    if (proc) {
        proc->PID = NextPID(); /* etc */
    }
    return proc;
}

void DisposeProcess(t_ProcessHandle proc)
{
    DisposeUsingDisposer(&(proc->_disposer));
}

O que acontece é que você faz declarações de avanço para as suas estruturas em seus arquivos de cabeçalho público. As tuas estruturas são opacas, o que significa que os clientes não se podem meter com elas. Então, na declaração completa, você inclui um destruidor no início de cada estrutura que você pode chamar genericamente. Você pode usar o mesmo alocador malloc para todos a mesma função de eliminação e assim. Você torna públicas as funções set/get para os elementos queres ser exposto.

O ponto importante é que existe um padrão de engenharia para tornar as estruturas seguras e inicializáveis.

Você pode escrever uma função que devolve a estrutura C:

struct file create_file(int i, float f) {
    struct file obj = { i, f };
    // other code here...
    return obj;
}

Se você se pergunta se você pode ter funções de membro "normal" em C. Bem, você pode até certo ponto. Prefiro o estilo objeto-como-primeiro-argumento. Você passa um ponteiro para sua estrutura como o primeiro argumento. Desta forma, poderá ter várias funções, definindo a interface para os seus objectos:

int file_get_integer(struct file *self) { return self->i; }
float file_get_float(struct file *self) { return self->f; }

Se você escrever nesse estilo, o que você tem no final é um tipo de dados abstrato. Já vi tipos a imitar o membro. sintaxe de chamada de função usada em C++, tendo ponteiros de função em sua estrutura e, em seguida, fazendo:

obj.get_integer(&obj);

É usado pelo kernel linux para definir a interface para os controladores de sistemas de ficheiros. É um estilo de escrita que se pode gostar, ou não gostar. Eu não gosto muito disso, porque eu continuo usando membros de estruturas para dados e não para emular chamadas de funções de membros para parecer em linguagens orientadas a objetos populares.

Basicamente, C++ cria listas de ponteiros que contêm os endereços dos métodos. Esta lista é chamada de definição de classe (há mais alguns dados na def de classe, mas nós ignoramos isso por enquanto).

Um padrão comum para ter " classes "em puro C é definir uma"classe struct". Um dos campos da estrutura é uma função de fábrica que retorna "instâncias" da classe. Sugiro usar uma macro para esconder os moldes.

typedef struct __class * class;
typedef void (*ctor_ptr)(class);
struct class {
    char * name;
    ctor_ptr ctor;
    ... destructor and other stuff ...
}

#define NEW(clz) ((struct something *)(((struct class *)clz)->ctor(clz)))

Se você quer métodos para suas instâncias, deve colocá-los nas estruturas de classe e manter um ponteiro para a classe na estrutura de instância:

#define NEW_SOMETHING() ((struct something *)NEW(&something_definition))
#define METHOD(inst, arg) ((struct something_class *)(((struct something *)inst)->clz)->method(inst, arg))

NEW_SOMETHING irá criar uma nova instância de "algo" usando a definição de classe armazenada na estrutura something_definition. O método irá invocar um "método" nesta instância. Note que para código real, você vai querer verificar se inst é realmente uma instância de something (compare os ponteiros de classe, algo assim).

Lembre-se que pode fazer tudo o que puder em C++ em puro C. um compilador C++ não substitui magicamente a sua CPU por outra coisa. É preciso muito mais código para o fazer.

Se quiser ver um exemplo, veja glib (parte do projecto Gtk+).

Assumindo que queres fazer isto em C, por isso a tua pergunta não é sobre estruturas em C++:

O que eu normalmente faço é que eu apenas crio uma função, init_whatever, que leva um ponteiro para a estrutura (ou outra variável), e define-a para os valores que eu quero.

Se é uma variável global (que é inicializada para zero) você poderia simular um construtor sem argumentos, tendo uma bandeira "inicializada" nela, e então deixar as suas outras funções verificar essa bandeira, e inicializar a estrutura se a bandeira for zero. Não tenho a certeza se isto é uma boa ideia.

Já foi mencionado o uso de funções para criar e eliminar estruturas. Mas em um comentário você mencionou que queria um "construtor padrão" - eu acho que você quer dizer que você quer inicializar alguns (Todos?) dos campos de struct aos valores padrão.

Isto é feito em C usando alguma convenção de codificação -- tanto funções, macros, ou uma mistura. Normalmente faço algo como o seguinte ...

struct some_struct {
    int a;
    float b;
};
#define some_struct_DEFAULT { 0, 0.0f}
struct some_struct *some_struct_create(void) {
    struct some_struct *ptr = malloc(sizeof some_struct);
    if(!ptr)
        return ptr;

    *ptr = some_struct_DEFAULT;
    return ptr;
}
// (...)
struct some_struct on_stack = some_struct_DEFAULT;
struct some_struct *on_heap = some_struct_create();

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define new(TYPE, ...) memdup(&(TYPE){ __VA_ARGS__ }, sizeof(TYPE))

void * memdup(const void * obj, size_t size)
{
    void * copy = malloc(size);
    return copy ? memcpy(copy, obj, size) : NULL;
}

struct point
{
    int x;
    int y;
};

int main()
{
    int * i = new(int, 1);
    struct point * p = new(struct point, 2, 3);

    printf("%i %i %i", *i, p->x, p->y);

    return 0;
}

#include        <stdio.h> 

void __attribute__ ((constructor)) default_constructor() 
{ 
    printf("%s\n", __FUNCTION__); 
} 

int main() 
{ 
    printf("%s\n",__FUNCTION__);
    return 0; 
}

Resultado: default_constructor principal

Dentro da função do construtor você pode incluir algumas declarações de inicialização na função do construtor e finalmente pode fazer libertando no destruidor como fallow,

#include    <stdio.h> 
#include    <stdlib.h>

struct somestruct
{
    int     empid;
    char *  name;
};

struct somestruct * str1;

void __attribute__ ((constructor)) a_constructor() 
{ 
    str1 = (struct somestruct *) malloc (sizeof(struct somestruct));
    str1 -> empid = 30228;
    str1 -> name = "Nandan";
} 

void __attribute__ ((destructor)) a_destructor()
{
    free(str1);
}

int main() 
{ 
    printf("ID = %d\nName = %s\n", str1 -> empid, str1 -> name);
    return 0;
}

É melhor dar uma vista de olhos num compilador C++. Ele lhe dá mais características orientadas a objetos do que você pode se lembrar em uma linguagem com uma sintaxe Tipo C de uma forma mais elegante e padrão do que tentar parafusar construtores e assim por diante Em C com bibliotecas e macros.

Da Wikipédia:

O sistema de objetos GLib, ou GObject, é uma biblioteca de software livre (coberta pela LGPL) que fornece um sistema de objetos Portáteis e uma interoperabilidade transversal transparente.