Tecnica para Programacao Orientada a Objetos emAnsi C∗

Andre Cavalcante1

1Departamento de Eletronica e TelecomunicacoesUniversidade Federal do Amazonas

andrecavalcante@ufam.edu.br

Abstract. It is recognized that the ANSI C language has become the mo-dern “assembly language” and it used virtually in all embedded or minimalsystem. Whether because of performance or portability or both, Ansi C isstill one of the most sought programming languages, mainly in engineering.However anybody wants to forego the new good programming practices ac-quired with object orientation. This paper aims to fill the gap that stillexists on how to use some techniques of object orientation using the ANSIC language, namely inheritance, polymorphism, and data hiding, but main-taining simplicity in the encoding.

Resumo. Reconhecidamente a linguagem C padrao Ansi tornou-se a “lin-guagem Assembly” moderna, utilizado virtualmente em todos os sistemasembarcados ou mınimos. Seja por causa de performance ou portabilidadeou ambos, Ansi C ainda e uma das mais procuradas linguagens de progra-macao, principalmente no ambito da engenharia. Entretanto nao se querabdicar das novas boas praticas de programacao adquiridas com a orien-tacao a objetos. Este artigo visa preencher a ainda existente lacuna emcomo usar algumas tecnicas de orientacao a objetos usando a linguagemAnsi C, nomeadamente, heranca, polimorfismo e ocultacao de dados, masmantendo-se simplicidade na codificacao.

1. Motivacao

Quando um fabricante de processadores coloca no mercado um novo dispositivos, eleo fara com um conjunto de ferramentas de software capaz de produzir programas querodem naquele sistema e, em geral, oferecera um compilador C (nao necessariamenteAnsi), um sistema operacional mınimo e bibliotecas de acesso ao hardware, tudoescrito em C, apensar de o formato final poder ser somente binario. Uma importanteparcela desses processadores sera usada na construcao de sistemas mınimos.

Sistemas mınimos sao aqueles com alguma capacidade de processamento,memoria e comunicacao, mas acoplados a um arcabouco fısico (mecanico e/ou ele-tronico) associado a sua funcao. Sao responsaveis por uma atividade unica, oupoucas simultaneas e, em geral, repetitivas, podendo operar autonoma ou quasi -autonomamente. Sao chamados de mınimos em comparacao com as capacidades de

∗Criado em: maio 2010. Ultima atualizacao: setembro 2011.

processamento, memoria e comunicacao, a um PC atual e nao necessariamente quesejam pequenos do ponto de vista de seu tamanho fısico, apesar de a parte relativaao processamento e memoria em geral ser fisicamente pequena.

Optamos por usar o termo sistema mınimo para diferencia-los dos chamadossistemas embarcados, os quais atualmente sao associados aos sistemas moveis (celu-lares, PDAs etc.) alimentos por bateria. Sistemas embarcados estao deixando de sermınimos, no sentido de suas capacidades de processamento, memoria e comunicacao,e sua programacao esta se tornando cada vez mais complexa.

Sistemas mınimos sao usados em situacoes especıficas, notadamente na in-dustria de manufatura, seja no controle de certas pecas, seja na criacao de sensorese atuadores inteligentes. Em geral sao programados em C (Ansi ou variante).

Com a proliferacao de varias linguagens modernas como Java e C# e dastecnicas orientadas a objetos, um sentimento de “so faz sentido programar algo emC se a aplicacao assim o exige” torna-se um lugar comum. Tais sentimentos eramcomuns anos atras quando se tratava da programacao em linguagem de montagem.E nesse sentido que dizemos que o C se tornou o “Assembly” moderno.

O leitor atento pode contestar que onde se possa usar C, em geral pode-se usar C++. De fato, com um port do GCC [?] para um dado processador, porexemplo, ganha-se de imediato tanto um compilador C como um C++, padraoAnsi. Entretanto muitos fabricantes nao querem disponibilizar um port aberto, ounecessitam inserir extensoes e especificidades (como por exemplo Dynamic C [?]).

Para sistemas mınimos, a programacao em C e dominante. Mesmo compila-dores C++ muitas vezes nao estao disponıveis ao desenvolvedor e, mesmo quandodisponıveis, caracterısticas inerentes a aplicacao como performance, tamanho docodigo binario gerado, caracterısticas temporais estritas e completo domınio da me-moria podem inviabilizar o uso deles.

Isso pode ser muito restrito a certas areas da engenharia, entretanto, aindae uma realidade no dia-a-dia das industrias de manufatura do Brasil e em outroslugares no mundo.

Em geral, a equipe de desenvolvimento de solucoes dentro da industria naoesta a vontade com as “tecnologias mais recentes”, sendo a mudanca do perfil desteprofissional uma realidade que esta a chegar.

Entretanto, o novo profissional, formado ja dentro do paradigma da orien-tacao a objetos nao se sente a vontade com as ditas “tecnologias ultrapassadas” asquais ainda tem que lidar.

Uma lacuna entao se estabelece: ha ainda necessidade de se usar o C, masse deseja a facilidade e agilidades conseguidas com outras linguagens. De qualquerforma, a linguagem C, e em especial Ansi C, se faz presente e ainda o sera por umbom tempo.

Daı a necessidade de uma abordagem orientada a objetos em Ansi C, que faza transicao necessaria do profissional atual para novas tecnologias e a conformacaodos novos profissionais aos dispositivos e ferramentas disponıveis.

A proposta deste trabalho e, pois apresentar uma tecnica de desenvolvimentoem Ansi C de alguns dos princıpios de orientacao a objetos, nomeadamente heranca,polimorfismo e ocultacao de dados. O desafio e fazer isto sem recorrer a elaboradastecnicas de uso da linguagem, como por exemplo as descritas por [?] o qual desenvolvetodo um arcabouco e uma API orientada a objetos usando Ansi C, mas a “magica”e complexidade intrınsecas podem limitar a sua adocao e aplicacao.

Para alcancar nossos objetivos vamos descrever primeiramente os princıpiosque norteiam a orientacao a objetos e entao passamos a descrever a nossa proposta.Vamos fazer isso com o desenvolvimento dos assuntos passo-a-passo, deixando sem-pre tudo o mais simples possıvel, aumentando gradativamente a complexidade, detal forma que um usuario apensas mediano de Ansi C podera compreende-lo, semdepender exaustivamente de manipulacao avancadas da linguagem e, por fim, des-creveremos uma API basica de um conjunto de objetos que podem ser usados emaplicacoes reais.

Utilizaremos como ferramentas de desenvolvimento o consagrado GCC [?]como compilador padrao, mas devidamente ajustado para Ansi C. Como editor decodigo e gerente de projetos utilizamos o Netbeans IDE [?]

2. Princıpios de POO

O acronimo POO significa Programacao Orientada a Objetos e e dito de toda pro-gramacao que tem por base o paradigma da orientacao a objetos. Portanto e umatecnica de programacao e nao esta associada necessariamente a uma linguagemqualquer.

Por outro lado, uma linguagem orientada a objetos e aquela que reforca emsua sintaxe e semantica aqueles princıpios, de tal forma que o programador que autiliza e forcado a utilizar de algumas tecnicas orientadas a objetos. Note que haainda as linguagens chamadas hıbridas, as quais permitem que o desenvolvedor possaconstruir programas utilizando tecnicas procedurais ou orientacao a objetos.

Os princıpios de orientacao a objetos que aqui nos interessa sao:

• Conceito de classe e objeto. classe e um modelo ou ainda uma abstracaode um conceito do mundo real, enquanto os objetos sao as instancias dasclasses, ou melhor a execucao real da abstracao. Se Carro for uma classe,formada por Motor + Chassi, entao uma Ferrari Enzo e um objetoque e formado por outros dois objetos: V12 Engine e Ferrari 2002respectivamente.

• Ocultacao de dados. E o princıpio que define que todos os detalhes de im-plementacao de uma classe devem estar escondidos (ocultos) de quem utilizaa classe por meio de uma interface bem definida. O nao acesso globalmentede dados locais e o princıpio numero 1 da orientacao a objetos.

• Heranca. Talvez a caracterıstica mais marcante da orientacao a objetos, aheranca define uma relacao do tipo isto E aquilo, ou ainda, uma relacao dotipo particularidade E generalidade. E a relacao mais forte que pode existirentre duas classes ou dois objetos.

• Polimorfismo. E o princıpio pelo qual uma funcao pode apresentar com-portamentos distintos por diferentes objetos, desde que esses tenham relacoes

do tipo heranca. Assim, diz-se que a funcao apresenta varias formas, isto e, epolimorfica, dependendo de qual objeto esta sendo referenciado em um dadocontexto. Pode-se obter o mesmo efeito em uma maquina de estados queexecuta transicoes diferentes, a partir de um mesmo evento, dependendo doestado em que a maquina esta, tornando a execucao da transicao (uma fun-cao) polimorfica. Da mesma forma, uma chamada de metodo de uma classeequivale a chamada de uma funcao de um objeto daquela classe ou de classesespecialistas (filhos) e, se o objeto referenciado na chamada do metodo forum objeto filho, entao funcoes especıficas serao chamadas a partir do mesmometodo tornando-o entao polimorfico.

3. Implementando Ocultacao de Dados em Ansi C

A forma mais simples e segura de implementar ocultacao de dados em Ansi C e ouso de tipos incompletos, o que pode ser feito conforme o exemplo da Listagem 1.

Listagem 1. Ocultacao de dados - interface� �1 #ifndef PERSON_H2 #define PERSON_H3

4 typedef struct Person * Person;5

6 Person new_Person(const char * name, const int age);7 void delete_Person(Person person);8 void print(Person person);9 char* getName(Person person);

10 int getAge(Person person);11

12 #endif /* PERSON_H */ � �Nessa listagem podemos ver a definicao do arquivo de cabecalho para um

tipo de dados chamado Person, o qual e definido de forma incompleta na linha4. Sendo assim, qualquer arquivo C que incluir este cabecalho tera acesso ao tipoPerson, mas nao tera acesso ao seu interior.

Se uma funcao tentar acessar um membro chamado name, (e.g.: printf("

Name: \%s\\n", myself->name)), entao o compilador ira reclamar com um erro:

main.c: In function ‘main’:main.c:16: error: dereferencing pointer to incomplete type

Qualquer acesso necessitara ser efetuado por meio das funcoes fornecidas, querealizam algumas operacoes sobre Person.

Assim, temos tambem as definicoes das funcoes que criam e liberam objetosdo tipo Person, e funcoes que manipulam um objeto Person, tais como a deimpressao das informacoes sobre a pessoa e de acesso ao nome e idade.

Vamos ver como e a implementacao de Person (o codigo pode ser vistona Listagem 2): primeiramente temos a definicao da estrutura struct Person edepois o seu uso dentro das diversas funcoes para manipular uma pessoa. Note quedentro de Person.c ha a possibilidade de acessar os membros da struct Personpois este e o lugar onde ela esta definida e, do ponto de vista da aplicacao, e umadefinicao local.

Listagem 2. Ocultacao de dados - implementacao� �1 #include <assert.h>2 #include <stdio.h>3 #include <stdlib.h>4 #include <string.h>5

6 #include "Person.h"7

8 struct Person {9 char name[80];

10 int age;11 };12

13 Person new_Person(const char * name, const int age) {14 Person person = malloc(sizeof(struct Person));15 assert(person);16 person->age = age;17 strcpy(person->name, name);18 return person;19 }20

21 void delete_Person(Person person) {22 free(person);23 }24

25 void print(Person pessoa) {26 printf("%s is %d years old\n", pessoa->name, pessoa->age);27 }28

29 char* getName(Person pessoa) {30 return pessoa->name;31 }32

33 int getAge(Person pessoa) {34 return pessoa->age;35 } � �

Com esta abordagem, pode-se pois conseguir ocultacao de dados da mesmaforma que se conseguiria em uma linguagem orientada a objetos, com toda a segu-ranca de verificacao de tipos inclusa.

Agora veja-se que a implementacao do nome da pessoa nao esta otimizadado ponto de vista do consumo de memoria, o que pode ser importante em aplicacoesde sistemas mınimos. Uma solucao com alocacao de memoria pode ser feita, comona Listagem 3, sem modificar nada dos programas que usam esta classe.� �

1 struct Person {2 char* name;3 int age;4 };5 Person new_Person(const char * name, const int age) {6 Person person = malloc(sizeof(struct Person));7 assert(person);8 person->age = age;9 person->name = strdup(name);

10 return person;11 } � �

4. Implementando Heranca em Ansi C

A heranca permite que um objeto de um certo tipo (de uma certa classe) possaser estendido para acomodar novas funcionalidades. Assim uma nova classe precisaser criada, que contenha as mesmas funcionalidades que a classe base e mais asespecializacoes proprias.

Diz-se que a heranca e a mais forte das relacoes, porque e uma relacao dotipo uma classe estendida E igual a classe base, exceto pelas suas especializacoes,ou seja, tudo o que a classe base tem, a classe estendida tambem possui.

Isso significa que posso, usando a heranca, ter um mecanismo de reuso po-deroso, uma vez que toda a funcionalidade de uma classe base pode ficar disponıvelpara outras classes, que adicionam novas funcionalidades.

Em termos de codigo, podemos associar uma classe, a qual possui dadosintrınsecos as structs em C. Entretanto, ha um problema aqui: enquanto classesadmitem codigo, structs nao. Tambem ha outro problema: se uma funcao esperareceber como parametro um objeto de uma certa classe, tambem deve ser capaz deaceitar, pelo mecanismo da heranca, todos os objetos das classes estendidas aquelaclasse base.

O primeiro problema e resolvido com um mecanismo simples de C: os pon-teiros para funcoes. Assim, cada parte do codigo de uma classe pode ser mapeadacomo um ponteiro para funcoes. A Listagem 3 mostra o arquivo de cabecalho comuma definicao de uma classe Object. Este arquivo serve como uma definicao dainterface da classe e tambem mostra uma funcao que cria novos objetos e uma quedestroi objetos.

Listagem 3. Objeto base - interface� �1 #ifndef OBJECT_H2 #define OBJECT_H3

4 #include <stdlib.h>5 #include "Bool.h"6

7 typedef struct Object * Object;8

9 struct Object {10 size_t size;11 Object (*clone)(Object this);12 bool (*equals)(Object a, Object b);13 };14

15 Object new_Object(void);16 void delete(Object obj);17

18 #endif /* OBJECT_H */ � �Objetos tem um tamanho: este campo e necessario para as operacoes elemen-

tares como clonagem. Objetos sao capazes de verificar se sao iguais a outros objetose prover uma copia de si mesmos. Notar que o clone de um objeto e outro objeto e,dependendo da definicao do que seja aquele objeto, podem ser considerados iguaisou diferentes.

O tipo bool foi definido por comodidade (em Bool.h): ele representa uminteiro que pode assumir true (valor 1) ou false (valor 0). Uma funcao de con-versao simples (na verdade uma expansao de macro) tambem e suprida (veja aListagem 21, nos Apendices).

A implementacao das funcionalidades basicas atribuıdas a todos os objetos emostrada na Listagem 4. Notar que aqui um objeto sera considerado igual a outrose, e somente se, as suas referencias apontarem para a mesma area em memoria.

Note-se igualmente que todas as funcoes de interface da classe, mapeadascomo ponteiros para funcoes, devem ser definidas com ao menos um parametro: areferencia ao objeto ao qual ele deva ser chamado. Isto normalmente nao e neces-sario em linguagens com suporte a orientacao a objetos, pois o compilador ja supreautomaticamente tal parametro. Em geral recebe os nomes this ou self ou equi-valente para indicar o objeto chamador. Optamos por usar o nome this e ele deveser sempre explicitado.

Listagem 4. Objeto base - implementacao� �1 #include <stdlib.h>2 #include <string.h>3

4 #include "Object.h"5

6 Object Object_clone(Object this);7 bool Object_equals(Object a, Object b);8

9 Object new_Object(void) {10 Object obj = calloc(1,sizeof(struct Object));11 obj->size = sizeof(struct Object);12 obj->clone = Object_clone;13 obj->equals = Object_equals;14 return obj;15 }16

17 void delete(Object obj) {18 free(obj);19 }20

21 Object Object_clone(Object this) {22 Object clone = calloc(1, this->size);23 memcpy(clone, this, this->size);24 return clone;25 }26

27 bool Object_equals(Object a, Object b) {28 return toBool(a == b);29 } � �

A funcao new_Object() merece uma explicacao melhorada: ela aloca es-paco para um novo objeto e inicializa os ponteiros para funcao com as funcoes supri-das internamente no arquivo. Note que outras implementacoes para estes ponteirossao possıveis, desde que as respectivas funcoes sejam fornecidas.

O outro problema, que e a implementacao da heranca em si mesma, podeser obtida com um pequeno “truque”: copiar todo o conteudo da estrutura base

na estrutura estendida, na mesma ordem em que os campos ocorrem. Feito isso,onde quer que um ponteiro para a estrutura base seja requerida, um ponteiro paraa estrutura estendida pode ser fornecida, sem nenhum erro, somente com um alertado compilador sobre o ponteiro do tipo errado.

Veja-se como isso funciona: vamos definir um segundo objeto em nossa hi-erarquia, um conjunto que e capaz de armazenar referencias para outros objetos,inclusive para outros conjuntos. Chamamos esse novo objeto de Set e esta definidona Listagem 5.

Listagem 5. Objeto conjunto - interface� �1 #ifndef SET_H2 #define SET_H3

4 #include "Object.h"5

6 typedef struct Set * Set;7 typedef struct set_private set_private;8

9 struct Set {10 size_t size;11 Object (*clone)(Object this);12 bool (*equals)(Object a, Object b);13 set_private set_data;14 void (*add)(Set this, Object elem);15 Object (*del)(Set this, Object elem);16 bool (*isPresent)(Set this, Object elem);17 };18

19 #endif /* SET_H */ � �Observar que a definicao de Set e coerente com Object e estende as suas

funcionalidades. Assim, um Set E um Object e pode igualmente ser inseridodentro de um Set. E possıvel um Set inserir-se a si mesmo (mas convenhamos,nao faz muito sentido).

Um problema nos chega rapidamente: se for necessario estender Objectem outros casos a forma de copiar e colar nao e solucao, apensar de simples, poisuma alteracao em Object vai requerer alteracao em cascata em todas as classes dahierarquia.

Mas, evitando-se a manipulacao com ponteiros, uma solucao simples e de-finir o corpo das estruturas como expansoes de macro. Entao uma estrutura queestendesse Object, utilizaria uma macro (digamos IObject) na propria definicao,como uma especie de extends Object do Java.

Entao precisamos modificar um pouco a nossa interface de Object, o que emostrado na Listagem 6. A macro extends colocada em Object.h nao expandepara nada, e o que se chama uma “sopa sintatica” para deixar o codigo mais parecidocom uma linguagem orientada a objetos, do ponto de vista de quem estende Object.

Listagem 6. Objeto base - interface corrigida� �1 #ifndef OBJECT_H2 #define OBJECT_H3

4 #include <stdlib.h>5 #include "Bool.h"6

7 #define extends8

9 typedef struct Object * Object;10

11 #define IObject\12 size_t size;\13 char name[20];\14 Object (*clone)(Object this);\15 bool (*equals)(Object a, Object b);\16 char* (*topchar)(Object this);17

18 struct Object {19 IObject20 };21

22 Object new_Object(void);23 void delete(Object obj);24

25 #endif /* OBJECT_H */ � �Veja-se que foi inserida uma nova funcao, que retorna uma descricao do objeto

como uma sequencia de caracteres: topchar().

Ja a Listagem 7 mostra como fica a definicao do objeto conjunto com aheranca funcionando.

Listagem 7. Set - interface corrigida� �1 #ifndef SET_H2 #define SET_H3

4 #include "Object.h"5

6 typedef struct Set * Set;7 typedef struct set_private set_private;8

9 struct Set {10 extends IObject11

12 set_private * set_data;13 void (*add)(Set this, Object elem);14 Object (*del)(Set this, Object elem);15 bool (*isPresent)(Set this, Object elem);16 };17

18 #endif /* SET_H */ � �A classe Set, por sua vez como nao possui uma sessao #define entao e

uma classe final, isto e, nao admite extensoes.

5. Implementando Polimorfismo em Ansi C

O ultimo dos principais princıpios da orientacao a objetos aqui abordados e a capa-cidade de uma funcao apresentar-se sobre diversas formas. Para implementar essacapacidade nao e necessario nada mais que a estrutura ja montada, isto e, TODAS asfuncoes inerentes a uma classe sao criadas como um ponteiro para funcao. A funcaoalvo que efetivamente realiza a atividade sera associada na inicializacao do objeto.Entao todas as chamadas para funcoes das classes (os metodos) sao realizadas atra-ves de uma indirecao, ou seja, ela sera um pouco mais lenta que uma chamada diretada funcao, mas ainda sera determinıstica (e convenhamos que essa diferenca somentesera perceptıvel em situacoes extremamente crıticas como na chamada da funcao emum laco com milhares de iteracoes).

Entretanto, essa indirecao nos fornece uma flexibilidade muito grande poispermite que uma funcao que use um objeto, isto e, chame um de seus metodos,possa chamar as funcoes corretas dos objetos das classes estendidas.

Vamos a um exemplo: suponha-se que queiramos criar um mecanismo paraimprimir objetos (mostrar alguma informacao a seu respeito). Entao para um objetobase, poderıamos ter algo como na Listagem 8).

Listagem 8. Object expandido� �1 #define IObject\2 size_t size;3 char name[20];4 ...5 char* (*topchar)(Object this); � �

O que significa que todo objeto pode retornar alguma informacao em formatode uma sequencia de caracteres. O novo campo name guarda o nome da classedaquele objeto. Na implementacao para nossos objetos, optamos pelas informacoesfornecidas tambem em Java, isto e, mostrar uma sequencia de caracteres com o nomeda classe seguida de ‘@’ (at), seguido do endereco de memoria do objeto.

Uma funcao de impressao de informacoes entao pode ser construıda como naListagem 9.

Listagem 9. Usando polimorfismo� �1 void println(Object obj) {2 printf("Object: %s\n", obj->topchar(obj));3 } � �

Para vermos como isto funciona, temos que desenvolver outra classe interes-sante e necessaria: String (veja-se a Listagem 10). Strings tambem sao objetose, portanto, esta classe e baseada em Object mas com algumas diferencas, nome-adamente as funcoes equals() e topchar(), pois adimite-se que duas stringssao iguais se seus conteudos forem iguais e tambem espera-se que, quando impresso,veja-se o seu conteudo e nao o seu endereco em memoria.

Listagem 10. String - interface� �1 #ifndef STRING_H2 #define STRING_H3

4 #include "Object.h"5

6 typedef struct String * String;7 typedef struct string_private string_private;8

9 struct String {10 extends IObject11

12 string_private * string_data;13 };14

15 String new_String(const char * text);16

17 #endif /* STRING_H */ � �A implementacao pode ser vista na Listagem 11. Observar tambem a decla-

racao de new_String().

Listagem 11. String - implementacao� �1 #include <assert.h>2 #include "String.h"3

4 struct string_private {5 const char * buf;6 };7

8 bool String_equals(Object a, Object b) {9 return toBool(!strcmp(a->topchar(a), b->topchar(b)));

10 }11

12 char * String_topchar(Object _this) {13 String this = (String)_this;14 return (char*)this->string_data->buf;15 }16

17 String new_String(const char * text) {18 String str = calloc(1,sizeof(struct String));19 assert(str);20 str->size = sizeof(struct Object);21 sprintf(str->name, "Object@%lx", (long)str);22 str->string_data = calloc(1,sizeof(struct string_private));23 assert(str->string_data);24 str->string_data->buf = text;25 str->topchar = String_topchar;26 str->equals = String_equals;27 return str;28 } � �

O campo str->name e mantido em compatibilidade com Object, massomente e usado quando do uso da funcao auxiliar objectName() (nao mostrada)que o retorna.

Para testar o polimorfismo, a Listagem 12 mostra uma funcao cria dois ob-jetos: um objeto puro e uma string, imprime-os e depois apaga-os da memoria.

Listagem 12. Funcao de teste� �1 int main(int argc, char** argv) {2 Object o1 = new_Object();3 String s1 = new_String("String test");4

5 println(o1);6 println(s1);7

8 delete(o1);9 delete(s1);

10 } � �Quando da execucao da funcao de impressao (veja a Listagem 12), esta usara

o metodo topchar() correspondente ao objeto passado como parametro, entaoimprimindo a saıda de ob1 ou de s1 conforme, o que pode-se ver abaixo:

Object: Object@8aa4030Object: String testPress [Enter] to close the terminal ...

Ou seja, a“mesma”funcao, do ponto de vista de quem usa, passou a comportar-se de maneiras diferentes, portanto apresentando um comportamento polimorfico.

6. Problemas com a proposta e as solucoes

Ha alguns problemas relativos ao gerenciamento de memoria, inicializacao corretadas variaveis e ponteiros para funcoes dentro das classes. Observando a imple-mentacao de new_String(), vista na Listagem 11, podemos verificar que ela naoinicializa corretamente todas as variaveis necessarias, por exemplo, nao ha atribuicaopara o metodo clone().

Da mesma forma, se aprofundarmos mais a hierarquia, os novos objetos naoremoverao adequadamente a memoria alocada pelas classes base.

Uma maneira de se resolver isso e justamente realizar a criacao em momentodiferente da inicializacao. Da mesma forma, permitir o encerramento adequadodas classes antes da sua liberacao. Isto e feito atraves de funcoes especiais: osconstrutores e os destrutores.

Construtores sao funcoes especiais que sao chamadas para a inicializacaocorreta da classe e os construtores sao chamados no seu termino.

Para isso, cria-se uma estrutura de dados para gerenciar as classes. Funcoesespeciais new() e delete() podem ser criadas para permitir a criacao e a destrui-cao de objetos de qualquer classe a partir das informacoes dessa estrutura de classe.Essas funcoes podem chamar os respectivos construtores e destrutores.

Os construtores e destrutores tambem ficam disponıveis para serem chama-dos pelas classes bases, quando da codificacao de seus construtores e destrutore.Assim, um contrutor de uma classe String deve chamar o construtor da classe

base Object antes de inicializar-se a sim mesmo. Da mesma forma, ao terminar adestruicao de todas as suas estruturas internas, deve chamar o destrutor de Object.

Construtores e destrutores parametriazados tambem podem ser fornecidos,entretanto, fica a cargo do usuario fazer a chamada do construtor e destrutor comparametros adequadamente, uma vez que as funcoes genericas new() e delete()nao os conhecem. Uma alternativa e a criacao de funcoes de criacao auxiliares, emgeral new_XXX() para chamar new() e o construtor adequado, com a vantagemde explicitar os parametros.

Outro problema relacionado com a orientacao a objetos e o aumento da com-plexidade inerente a codificacao de uma estrutura que o compilador nao da suportedireto. Neste sentido a nossa proposta manteve-se sempre o mais simples possıvel,evitando-se ao maximo indirecoes nao necessarias, e mantendo-se o uso direto dascaracterısticas da linguagem Ansi C.

Em nossa proposta ha poucas regras necessarias para se criar uma estruturade classes totalmente funcional com as caracterısticas de heranca, polimorfismo eencapsulamento de dados e acreditamos ser essa a nossa maior contribuicao emrelacao a outras existentes.

Entretanto teremos que inserir algumas indirecoes a mais, porque o tamanhodas estruturas em memoria podem sofrer aumentos absurdos quando da criacao devarios objetos que contem grandes estruturas internas. Para reduzir isso, todos osmembros devem ser transformados em ponteiros. Tambem nao ha possibilidade determos um buffer de tamanho variavel, pois o posicionamento rıgido dos camposdentro da estrutura e que torna possıvel a heranca e o polimorfismo, transformandovirtualmente qualquer campo que nao seja do tipo ordinal (caractere, inteiro, boo-leano) ou ponto flutuante em um ponteiro, isto e, qualquer coisa como sequencias,unioes, estruturas e outros objetos.

Entretanto, tais indirecoes nao afetarao muito a simplicidade do codigo, antesira simplificar pois somente um unico sinal sera previsıvel apos o nome de umavariavel do tipo objeto: o operador de derreferenciacao de estruturas ->.

Ha alguns ganhos com isso: ganha-se em termos de eficiencia na execucao,diminuicao do uso da memoria e mesmo o tamanho final do binario se torna bempequeno. Essas sao as caracterısticas que determinam o uso de Ansi C e entao elasdevem ser respeitadas e sao o porque termos dedicado algum tempo na elaboracaodesta proposta: conseguir uma orientacao a objetos em Ansi C, da forma maissimples possıvel.

7. Versao final

Aqui descreveremos a estrutura final do arcabouco (framework) orientado a objetosem Ansi C.

7.1. Class

A estrutura de gerenciamento das classes, chamada Class, e claro, pode ser visua-lizada na Listagem 13.

Essa estrutura deve ser estaticamente criada na criacao da classe e depois umponteiro para ela1 pode ser usado para a criacao de objetos daquela classe, atravesde new(descriptor) e destruıdos atraves de delete(object). E importanteusar as funcoes pois elas chamam os construtores e destrutores padrao das classes.

Listagem 13. Informacoes sobre uma Classe� �1 #ifndef CLASS_H2 #define CLASS_H3

4 #include <stdlib.h>5

6 #define extends7

8 typedef struct Class * Class;9

10 struct Class {11 const size_t size;12 const char * name;13 void * (*ctor)(void * this);14 void * (*dtor)(void * this);15 };16

17 void * new(Class class);18 void * delete(void * obj);19 char * className(void * obj);20 size_t sizeOf(void * obj);21

22 #endif /* CLASS_H */ � �A Listagem 14 mostra o arquivo de implementacao para a estrutura Class.

Observar especialmente a implementacao de new() e delete().

Listagem 14. Implementacao da estrutura Class� �1 #include <assert.h>2 #include <stdlib.h>3

4 #include "ooc.h"5

6 void * new(Class class) {7 Object obj = calloc(1, class->size);8 if(obj) {9 obj->class = class;

10 if(class->ctor) {11 obj = class->ctor(obj);12 }13 }14 return obj;15 }16

17 void * delete(void * _obj) {18 Object obj = (Object)_obj;19 if(obj && obj->class->dtor) {20 obj = obj->class->dtor(obj);21 }22 free(obj);23 return NULL;

1Esse ponteiro e chamado de descritor da classe.

24 }25

26 char * className(void * _obj) {27 assert(_obj);28 Object obj = (Object)_obj;29 return (char*)obj->class->name;30 }31

32 size_t sizeOf(void * _obj) {33 assert(_obj);34 Object obj = (Object)_obj;35 return obj->class->size;36 } � �

Se um construtor ou destrutor padrao nao for fornecido, cabe ao usuario daclasse fazer a chamada explıcita ao construtor ou destrutor parametrizado, isto e,construtor com parametros, em geral new_XXX(params).

7.2. Object

O arquivo de cabecalho e o arquivo de implementacao de Object, vistos nas Lis-tagems 15 e 16, mostra como e o uso de Class e a definicao das funcionalidadesbasicas de todos os objetos: podem ser clonados, possuem uma descricao textual desi mesmos, podem ser comparados uns com os outros.

Listagem 15. Definicao de Object� �1 #ifndef OBJECT_H2 #define OBJECT_H3

4 #include <stdlib.h>5 #include "Bool.h"6 #include "Class.h"7

8 extern const Class ObjectClass;9

10 typedef struct Object * Object;11 typedef struct object_private * object_private;12

13 #define IObject \14 Class class; \15 \16 object_private object_data; \17 void * (*clone) (Object this); \18 bool (*equals) (Object a, Object b); \19 char * (*topchar)(Object this);20

21

22 struct Object {23 IObject24 };25

26 Object new_Object(void); //wrapper for new(ObjectClass)27 void * Object_ctor(void * this); //contructor default28 void * Object_dtor(void * this); //destructor29

30 void * Object_clone(Object this);31 bool Object_equals(Object a, Object b);32 char * Object_topchar(Object this);

33

34 #endif /* OBJECT_H */ � �Optamos por deixar new, delete, os construtores e destrutores recebendo e

devolvendo void * para que nao houvesse a necessidadede se fazer um cast sempreque essas funcoes fossem utilizadas, o que e feito com frequencia. Tambem evita-se amensagem de atencao (o warning) do compilador e ainda evita-se a inclusao cıclicade Class.h e Object.h.

Listagem 16. Implementacao de Object� �1 #include <stdlib.h>2 #include <string.h>3 #include <stdio.h>4 #include <assert.h>5

6 #include "ooc.h"7

8 struct Class _ObjectClass = {9 sizeof(struct Object),

10 "Object",11 Object_ctor,12 Object_dtor13 };14

15 const Class ObjectClass = &_ObjectClass;16

17 struct object_private {18 char disp[15];19 };20

21 void * Object_clone(Object this);22 bool Object_equals(Object a, Object b);23 char * Object_topchar(Object this);24

25 Object new_Object(void) {26 return new(ObjectClass);27 }28

29 void * Object_ctor(void * _this) {30 Object this = (Object)_this;31 this->object_data = calloc(1,sizeof(struct object_private));32 assert(this->object_data);33 sprintf(this->object_data->disp, "%s@%lx", this->class->name,

(long)this);34 this->clone = Object_clone;35 this->equals = Object_equals;36 this->topchar = Object_topchar;37 return this;38 }39

40 void * Object_dtor(void * _this) {41 Object this = (Object)_this;42 free(this->object_data);43 this->object_data = NULL;44 return this;45 }46

47 void * Object_clone(Object this) {

48 Object clone = calloc(1, this->class->size);49 memcpy(clone, this, this->class->size);50 return clone;51 }52

53 bool Object_equals(Object a, Object b) {54 return toBool(a == b);55 }56

57 char * Object_topchar(Object this) {58 return this->object_data->disp;59 } � �

O arquivo de cabecalho ooc.h foi criado para simplificar a inclusao doscabecalhos framework que estamos construindo (veja os Apendices). Assim, se umaaplicacao utilizar este framework basta fazer a inclusao de ooc.h.

7.3. Set

Para se criar uma classe deve-se estender Object, criar um descritor para classe,isto e, um ponteiro para Class, definir o typedef para a estrutura que contera adefinicao da classe e, se a classe nao for final, isto e, poder ser estendida, entao secriar o conteudo dessa estrutura como uma macro. A criacao da estrutura em si esimplesmente inserir-se a macro dentro da estrutura de mesmo nome da classe.

Orienta-se tambem a implementar a funcao new_ClassName() para o casode criacao parametrizada e o construtor padrao (sem parametros2).

Isto pode se visto na Listagem 17. A sua funcionalidade e facilmente per-ceptıvel: ha um metodo para adicionar, outro para testar a existencia de um objetodentro de um conjunto, outro para remover e outro para retornar a quantidadede elementos dentro do conjunto. Para realizar iteracoes com os elementos de umconjunto, uma classe Iterator tambem e definida no mesmo arquivo.

Listagem 17. Definicao de Set� �1 #ifndef SET_H2 #define SET_H3

4 #include "Object.h"5

6 typedef struct Iterator * Iterator;7 typedef struct iterator_private * iterator_private;8

9 struct Iterator {10 extends IObject11 iterator_private iterator_data;12 bool (*hasNext)(Iterator this);13 Object (*next) (Iterator this);14 };15

16 extern const Class SetClass;17

18 typedef struct Set * Set;

2O.K. tera um parametro, o ponteiro para a classe this mas este e obrigatorio em todos os metodosda classe

19 typedef struct set_private * set_private;20

21 #define ISet\22 extends IObject\23 \24 set_private set_data;\25 void (*add)(Set this, Object obj);\26 bool (*belongs)(Set this, Object obj);\27 Object (*del)(Set this, Object obj);\28 int (*size)(Set this);\29 Iterator (*iterator)(Set this);30

31 struct Set {32 ISet33 };34

35 Set new_Set();36 void * Set_ctor(void * this);37 void * Set_dtor(void * this);38

39 #endif /* SET_H */ � �Outras classe de interesse que manipulam conjunto de objetos e fazem parte

deste framework sao:

• classe Queue: implementa em uma lista ligada as funcionalidades de umafila FIFO: add() para inserir um elemento na fila, next() para obter oelemento sem remove-lo e remove() para remover o proximo elemento dafila.

• classe Stack: implementa em uma lista ligada as funcionalidades de uma filaLIFO: push(elem) para adicionar um elemento no topo da pilha pick()para pegar um elemento do topo da pilha e pop() para retirar um elementodo topo da pilha.

• classe Array: implementa as funcionalidades de um vetor: add() paraadicionar no fim do vetor, set(index) para substituir um elemento a partirdo seu ındice, get(index) para pegar um elemento a partir do seu ındice edel(index), remover um elemento a partir do seu ındice e obter um ındicea partir do elemento indexOf(elem).

Todas essas classes possuem um metodos size() que retorna a quantidadede elementos do conjunto. Devido ao tamanho de suas implementacoes nao seraoaqui mostradas, mas foram todas implementadas.

7.4. Classes concretas e abstratas

Classes concretas sao aquelas em que se e possıvel a criacao de instancias, isto e, deobjetos daquele tipo. Classes abstratas sao aquelas que nao permitem a criacao deobjetos, porque nao ha implementacao para algumas ou todas as suas funcionalida-des. Elas existem como um modelo para outras classes.

Note-se que a criacao de uma classe abstrata e possıvel nesta nossa arqui-tetura simplesmente nao se definindo o ponteiro para a estrutura de definicao da

classe (o chamado descritor da classe). Sem ele nao se e possıvel criar instancias (osobjetos) daquela classe a partir de new e toda a definicao simplesmente e passadapara as classes estendidas.

Alem disso, pode-se ter ou nao um arquivo de implementacao (o .c associadocom o cabecalho). Se ela mesma contiver uma parte das funcionalidades, podepossuir dados internos, mas construtores e destrutores deverao ser providenciados.Se nao possuir arquivo de implementacao entao nao devera tambem possuir dadosinternos escondidos.

Em nossa estrutura, uma classe Collection poderia ser criada como basepara conjuntos, arrays e filas, entretanto, optou-se por deixar o codigo sempre omais limpo e com a menor profundidade da hierarquia de classes possıveis.

7.5. Time

Uma caracterıstica importante para aplicacoes industriais e a capacidade de lidarcom o tempo. Neste sentido, criou-se uma classe Time para a definicao do tempo euma Timer para criacao de temporizadores.

Um tempo e um valor dado em milissegundos. Um temporizador e umaestrutura que executa um evento (um de seus metodos) apos um tempo decorrido.

Listagem 18. Definicao de Time e Timer� �1 #ifndef TIME_H2 #define TIME_H3

4 //TODO: insert code here5

6 #endif /* TIME_H */ � �7.6. Classes Wrappers

As demais classes de nossa estrutura sao apenas cascas (wrappers) para os tiposprimitivos (inteiros, booleanos e de ponto flutuante) e mais o tipo String que euma casca para char *.

7.6.1. Integer, Long, Boolean e Double

Todas as classes de casca para tipos primitivos possuem metodos para ajustar eretornar o valor como tipo primitivo e construtores a partir do tipo primitivo e apartir de uma String e de um char*.

A classe Integer e uma casca para os tipos inteiros simples e sua definicaoe mostrada na Listagem 19.

Listagem 19. Definicao de Integer� �1 #ifndef INTEGER_H2 #define INTEGER_H3

4 #include "Object.h"5 #include "String.h"

6

7 extern const Class IntegerClass;8

9 typedef struct Integer * Integer;10 typedef struct integer_private * integer_private;11

12 #define IInteger\13 extends IObject\14 \15 integer_private integer_data;\16 void (*setValue)(Integer this, int value); \17 int (*getValue)(Integer this);18

19

20 struct Integer {21 IInteger22 };23

24 Integer new_Integer(int value);25 Integer from_String(String value);26 Integer from_PChar(char * value);27 void * Integer_ctor(void * this);28 void * Integer_dtor(void * this);29

30 #endif /* INTEGER_H */ � �A classe Long e uma casa para o inteiro long, a Boolean e uma casca para

bool e a classe Double e uma casca para os tipos de ponto flutuante.

7.6.2. String

Outra classe de casca importante e a classe String a qual possui metodos de ma-nipulacao de sequencias e construtores parametrizados de todos os tipos primitivosalem de char*. Alem de conversoes, esta classe e ideal para concatenacao de stringse outras manipulacoes. Devido ao tamanho do codigo so sera mostrada as primeiraslinhas da definicao.

Listagem 20. Definicao de String� �1 #ifndef STRING_H2 #define STRING_H3

4 #include "Object.h"5

6 extern const Class StringClass;7

8 typedef struct String * String;9 typedef struct string_private string_private;

10

11 struct String {12 extends IObject13

14 string_private * string_data;15 void (*appendBool)(String this, bool value);16 void (*appendChar)(String this, char chr);17 void (*appendDouble)(String this, double value);18 void (*appendInt)(String this, int value);

19 void (*appendLong)(String this, long value);20 void (*appendPChar)(String this, char* value); � �

8. Conclusao e Trabalhos Futuros

A criacao de software usando as modernas tecnicas da orientacao a objetos pode seracessıvel mesmo a plataformas que carecam de ferramentas e linguagens orientadasa objetos, notadamente Java e C#.

Desde que plataforma forneca um compilador Ansi C (a maioria delas) epossıvel o desenvolvimento de um framework de orientacao a objetos, como o aquidesenvolvido.

O projeto em questao motivou-se da necessidade de alta performance e baixofootprint em uma aplicacao distribuıda, cujos nodos possuem baixas capacidades deprocessamento e memoria, daı a opcao de se utilizar Ansi C.

Tais dispositivos, chamados de mınimos, serao utilizados no desenvolvimentode middleware para sistemas multi-agentes na manufatura. Tal sistema sera descritoem um trabalho futuro e ja se encontra em desenvolvimento.

Apendices

Apendice 1

A definicao do tipo booleano (bool) pode ser vista na Listagem 21.

Listagem 21. Definicao do tipo booleano� �1 #ifndef BOOL_H2 #define BOOL_H3

4 #define true 15 #define false 06 typedef int bool;7

8 #define toBool(exp) ((exp)?true:false);9

10 #endif /* BOOL_H */ � �Apendice 2

O arquivo de cabecalho ooc.h foi criado para simplificar a inclusao dos cabecalhosframework construıdo.

Listagem 22. Inclui todos os cabecalhos� �1 #ifndef OOC_H2 #define OOC_H3

4 #include "Bool.h"5 #include "Class.h"6 #include "Object.h"7 #include "Array.h"8 #include "Boolean.h"9 #include "Double.h"

10 #include "Integer.h"11 #include "Queue.h"12 #include "Set.h"13 #include "Stack.h"14 #include "String.h"15

16 #endif /* OOC_H */ � �