Como você implementa uma aula em C?

1. Defina os seus dados num estrutura.
2. Defina os seus membros de funções que tome um ponteiro para a sua estrutura como primeira discussão.
3. faça isso em um cabeçalho & um C. Cabeçalho para a definição do struct & declarações de funções, c para implementacao.

Um exemplo simples seria este:

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

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

Se só quiser uma classe, use um array de {[[0]} s como os dados dos " objectos "e passe-lhes pontos para as funções de" membro". Você pode usar typedef struct _whatever Whatever Antes de declarar struct _whatever para esconder a implementação do Código do cliente. Não há diferença entre esse "objeto" e a biblioteca padrão C FILE objeto.

Se você quer mais de uma classe com funções hereditárias e virtuais, então é comum ter ponteiros para as funções como membros da estrutura, ou um ponteiro compartilhado para um tabela de funções virtuais. A biblioteca GObject usa tanto este como o truque typedef, e é amplamente usado.

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

C Interfaces e Implementações: Técnicas para a Criação de Software Reutilizável, David R. Hanson

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

/* for data structure foo */

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

Miro Samek desenvolveu um framework c orientado a objectos para o seu framework de máquina de estado: http://sourceforge.net/projects/qpc e também escreveu um livro sobre isso: http://www.state-machine.com/psicc2/.

Use a struct para simular os dados de uma classe. Em termos de âmbito do método, pode simular métodos privados colocando os protótipos da funçãoprivada na .C file and the public functions in the .h file.

Vou dar um exemplo simples de como OOP deve ser feito em C. Eu sei que este thead é de 2009, mas gostaria de adicionar isto de qualquer maneira.

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

Quanto às funções virtuais, use ponteiros de função na estrutura, possivelmente com Class_func (...); wrapper too. Quanto aos modelos (simples), adicione um parâmetro size_t para determinar o tamanho, necessite de um ponteiro vazio*, ou requeira um tipo de 'classe' com apenas a funcionalidade com que te preocupas. (por exemplo, int GetUUID (Object *self); GetUUID (&p);)

No teu caso, a boa aproximação da classe pode ser o anADT . Mas mesmo assim não será a mesma coisa.

• Define todo o código para a classe num ficheiro separado
• Define todas as interfaces para a classe num ficheiro header separado
• todas as funções de Membros tomam um "ClassHandle" que está em nome da instância (em vez de O. foo(), chamar foo(oHandle)
• o construtor é substituído por uma função classinit vazio(ClassHandle h, int x, int y,...) Ou Classhandle ClassInit (int x, int y,...) dependendo da estratégia de alocação de memória
• todos as variáveis de membro são armazenadas como um membro de uma estrutura estática no arquivo de classe, Encapsulando-o no arquivo, impedindo arquivos externos de acessá-lo
• os objectos são armazenados numa matriz da estrutura estática acima, com pegas predefinidas (visíveis na interface) ou um limite fixo de objectos que podem ser instanciados
• Se for útil, a classe pode conter funções públicas que irão circular através do array e chamar as funções de todos os objectos instanciados (RunAll() chama cada um Corre (oHandle)
• Uma função Deinit (ClassHandle h) liberta a memória atribuída (Índice de matriz) na estratégia dinâmica de atribuição

Programação Orientada a objectos em ANSI-C

Consulte Também esta resposta e esta

Os dados escondidos com funções get / set são fáceis de implementar em C mas pára aí. Tenho visto várias tentativas para isso no ambiente embutido e no final é sempre um problema de manutenção.

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

A minha abordagem seria mover as funções struct e todas primariamente associadas para um(s) ficheiro (S) Fonte (s) separado (s) para que possa ser usado "portavelmente".

, Dependendo do seu compilador, você pode ser capaz de incluir funções para o struct, mas isso é uma muito compilador específico de extensão, e não tem nada a ver com a última versão da norma eu rotineiramente utilizados :)

O primeiro compilador C++ Foi na verdade um pré-processador que traduziu o código C++ Para C.

GTK é construído inteiramente em C e usa muitos conceitos OOP. Eu li através do código fonte de GTK e é muito impressionante, e definitivamente mais fácil de ler. O conceito básico é que cada "classe" é simplesmente uma estrutura, e funções estáticas associadas. Todas as funções estáticas aceitam a estrutura de "instância" como um parâmetro, fazem o que for preciso e retornam os resultados se necessário. Por exemplo, você pode ter uma função "GetPosition(CircleStruct obj)". A função iria simplesmente escavar através da estrutura, extrair os números de posição, provavelmente construir um novo objeto PositionStruct, colocar o x e y na nova posição, e devolvê-lo. GTK ainda implementa herança desta forma, incorporando estruturas dentro de estruturas. muito inteligente.

Se não for assim, basta definir um conjunto de ponteiros de função na própria estrutura. Se você atribuir todos os ponteiros de função para funções C padrão, então você será capaz de chamar funções de C em sintaxe muito semelhante ao que você faria em C++.

Mas a tuberculose ... se você quiser o último, então você provavelmente está melhor apenas encontrar um compilador C++ que você pode usar e re-compilar o projeto. Eu nunca entendi a obsessão com C++ não ser utilizável no embedded. Eu usei-o muitas vezes e ele funciona é rápido e não tem problemas de memória. Certo tens de ter um pouco mais de cuidado com o que fazes, mas não é assim tão complicado.

C não é uma língua OOP, como o seu ponto correcto, por isso não há uma forma integrada de escrever uma classe verdadeira. A melhor aposta é olhar para as estruturas, e para os ponteiros de função , estas irão permitir-lhe construir uma aproximação de uma classe. No entanto, como C é processual você pode querer considerar escrever mais código C-like (ou seja, sem tentar usar classes).

Também, se você pode usar C, você pode provavelmente usar C++ e obter classes.