Toda matéria, independente de seu estado (sólido, líquido ou gasoso), é composta por átomos. E um átomo, por sua vez, é composto por prótons, nêutrons e elétrons.

Um átomo é uma partícula tão minúscula que, até recentemente, não existia um instrumento (como um super-microscópio) capaz de visualizá-lo (pois ele tem o tamanho de cerca de 0,2 nanômetros, e isso é muito, muito pequeno!).

Para se ter uma ideia de como um átomo é pequeno, se fosse possível cair até o nível atômico dentro de um grão de areia, seria como pular de um avião a 2,5 km de altitude. Como nessa cena do Homem-Formiga:

Hoje já existem alguns microscópios quânticos que conseguem visualizar coisas na ordem dos picômetros.

Mas com base nos experimentos e observações dos cientistas há mais de 100 anos atrás, sem precisar de um microscópio quântico, o modelo de Rutherford-Bohr foi criado para trazer uma representação visual de um átomo. Este modelo nos ajuda a compreender a relação entre os elétrons e o núcleo atômico.

A real é que a movimentação dos elétrons em torno do núcleo não é tão perfeita como no modelo de Rutherford-Bohr, mas vamos nos ater a este modelo por ser mais didático e nos proporcionar uma boa ideia de como a eletricidade funciona.

Os prótons possuem linhas de força ao seu redor formando um campo elétrico dito como positivo. Eles repelem outros prótons, pois suas linhas de força são iguais e, portanto, incompatíveis.

Os elétrons também possuem um campo elétrico ao seu redor, mas as linhas de força tem um sentido diferente ao dos prótons. O campo elétrico dos elétrons é tido como negativo.

Já os nêutrons são partículas que não possuem campo elétrico (mas são importantes para permitir que vários prótons consigam ficar juntos no núcleo de um átomo sem que se repilam).

Elétrons repelem elétrons, mas eles se atraem a prótons, pois as linhas de força dos dois são compatíveis.

Estas mesmas linhas de força que atrai um elétron a um próton não permite que um “cole” no outro. Ou seja, faz com que o elétron sempre fique ao redor do próton, mas nunca “pregado” nele.

A força de atração entre um próton e um elétron, ou a força de repulsão entre cargas iguais são calculadas pela lei de Coulomb.

Exatamente quantos prótons e quantos elétrons um átomo possui, vai depender de qual elemento químico estamos falando.

• 1 elétron orbitando 1 próton constitui um átomo de hidrogênio.
• Se acrescentar mais 1 próton e mais 1 elétron ele se transforma em um átomo de hélio.
• Com 3 prótons e 3 elétrons temos o lítio, com 4 prótons e 4 elétrons, o berílio. Com 5 prótons e 5 elétrons, o boro… e assim os elementos químicos vão se formando.
• Observa-se que a quantidade de elétrons é igual a quantidade de prótons de um átomo. Mas nem sempre é assim! Dependendo do elemento químico, da temperatura, e de outros fatores, a quantidade de elétrons de um átomo pode ser menor que a quantidade de prótons (mesmo que temporariamente).
• Um átomo é considerado neutro quando a quantidade de prótons e elétrons estão balanceados. Mas se estiver faltando um elétron ele vai ficar sempre tentando atrair um novo elétron para voltar a ficar balanceado.

Mas se os prótons se repelem, como é possível que dois deles co-existam no núcleo, por exemplo, de um átomo de hélio? Na natureza, existem 4 tipos de forças fundamentais: gravidade, eletromagnetismo, força nuclear forte e força nuclear fraca. Esse “nuclear” vem de núcleo, e é justamente esse tipo de força que impede a repulsão dos prótons de um átomo. Existe toda uma explicação quântica para isto, mas, em resumo, os nêutrons, apesar de não possuir carga, influenciam nesta “força nuclear forte” para manter os prótons unidos.

Observa-se que quanto mais elétrons girando em torno do núcleo, mais camadas de elétrons vão surgindo. Logo, um átomo com muitos prótons possuirá também muitos elétrons orbitando em torno dele em várias camadas diferentes (camadas mais próximas do núcleo e camadas mais distantes do núcleo).

Existem elementos químicos com quantidades exageradas de prótons, elétrons e nêutrons, como o ouro (com 79 prótons e 79 elétrons), a prata (com 47 prótons e 47 elétrons), e o cobre (com 29 prótons e 29 elétrons).

Até existem vários outros elementos químicos com muito mais elétrons e prótons, mas elementos acima de 84 prótons já são considerados elementos radioativos (devido a grande quantidade de energia retida em seus átomos), além de muitos não serem facilmente encontrados na natureza.

Os elétrons das camadas mais distantes do núcleo possui uma força de atração mais fraca, podendo se desprender do núcleo e partir para a órbita de outros átomos. Estes são os elétrons livres.

Os elétrons livres são mais presentes em materiais cujo elemento químico possui várias camadas de elétrons (como os já citados ouro, prata e cobre, por exemplo). Estes materiais que tem facilidade de comportar muitos elétrons livres são chamados de materiais condutores, e são justamente eles que são aproveitados como meio para conduzir uma movimentação intensa e uniforme em um único sentido desses elétrons para uma direção, também conhecido como corrente elétrica (vamos falar mais disso agora a pouco).

Em temperaturas normais, os elétrons livres ficam se movimentando pelo material condutor (mas sem gerar corrente, pois são movimentações aleatórias onde o espaço por um é logo ocupado por outro).

Eletricidade estática

Dependendo da tendência que um objeto tem de perder ou ganhar elétrons, caso ele seja atritado com outro material, a transferência de elétrons pode ocorrer fazendo com que um material fique com excesso de elétrons e o outro com um déficit de elétrons.

Exatamente quais materiais quando atritados irão gerar transferência de elétrons pode ser listados pela série triboelétrica:

Em tempos secos, o atrito de nossas roupas com o estofado do banco do carro pode fazer nossos corpos perderem elétrons. Ao encostar na lataria do carro, os elétrons livres da lataria tentarão repor o déficit de elétrons dos nossos corpos, gerando um choque.

Os raios são formados dentro das nuvens de tempestade devido ao acúmulo de cargas positivas na parte superior e de cargas negativas na parte inferior. Outra possibilidade são as cargas negativas acumuladas na parte inferior das nuvens se atraírem a carga positiva do solo.

Para lidar com os possíveis problemas gerados pela eletrostática no dia-a-dia (como choques ou queima de dispositivos eletrônicos sensíveis) o aterramento é a solução, oferecendo um caminho condutivo a terra (ou outro material eletricamente neutro).

• para evitar a queima de dispositivos, é recomendado o uso de pulseira eletrostática.
• caminhões tanque possuem aterramento para evitar acidentes durante abastecimento de postos de combustível.

Diferença de potencial elétrico e formação da corrente

Fontes de geração de eletricidade

Circuitos e resistência

Diagramas esquemáticos

Indutor (bobina)

Capacitor

Semicondutores (diodos e transitores)

Corrente alternada

Durante um tempo fiquei pensando que experimento didático é possível de ser feito para consolidar os principais conceitos de eletrônica analógica.

Hoje em dia, o “hello world” da eletrônica é fazer um pequeno semáforo de leds.

Com o Arduino podemos fazer um semáforo mas, por mais legal que seja esse primeiro contato, ainda existem muitas complexidades e abstrações envolvidas em um simples piscar de leds: um software em C++ é compilado e armazenado na memória de um microcontrolador e este, por sua vez, através do processamento de múltiplas instruções lidas da memória, controla a saída de tensão em determinados pinos do chip.

Outra maneira de se criar um semáforo é usando um timer 555. Aqui não temos mais um software e nem um microcontrolador. A frequência do piscar dos leds já são “programadas” através da combinação de resistências e capacitâncias.

Mas ainda sim tempos um chip abstraindo coisas (com transistores, diodos e resistores dentro dele).

Então, será que existe uma forma de se criar um semáforo usando apenas transistores, capacitores, resistores, e leds?

Foi aí que encontrei o canal do “Burgos Eletrônica” no YouTube que apresentava um diagrama esquemático justamente do que eu estava procurando:

Com este experimento podemos ver na prática os conceitos de:

• análise de diagrama esquemático.
• circuito em série e paralelo.
• tensão.
• resistência e lei ohm.
• lei de kirchhoff.
• capacitância.
• transistor NPN.
• diodo emissor de luz.

Vale muito a pena estudar o slide dele!

Fiquei muito empolgado com a ideia de poder entender orientação a objetos explorando recursos da linguagem C. Como sou um curioso dessa linguagem, deixo aqui neste artigo algumas anotações sobre esse tema.

Contextualizando

As várias linguagens de programação existentes podem ser classificadas de acordo com seus paradigmas. Podemos listar alguns dos paradigmas como:

• Estruturado.
• Procedural.
• Orientado a Objetos.
• Orientado a Eventos.
• Funcional.
• Declarativo.
• Lógico.
• Paralela.

Um paradigma irá determinar a visão que o programador terá do código, ou seja, determinará como o programador irá pensar o código de uma aplicação.

Muitas linguagens de programação são multi-paradigma, suportando nativamente um ou mais paradigmas. Como é o caso da linguagem C que suporta nativamente os paradigmas procedural e estruturado.

Um ponto interessante a se saber é que é possível emular um paradigma sobre uma linguagem que não a suporta nativamente. Por exemplo: é possível emular programação funcional ou orientada a objetos sobre a linguagem C.

É claro que essa emulação não terá a qualidade esperada de uma linguagem que a suporta nativamente. Então por que alguém se daria o trabalho de fazer uma gambiarra dessas? Vamos pontuar algumas possíveis justificativas:

1. o programador pode apenas estar tentando se tornar mais íntimo de um paradigma específico, tentando entender a sua implementação.

2. um paradigma mais elaborado (como o OO) poderá ser emulado sobre uma linguagem mais simples por razões de performance (como por exemplo em sistemas embarcados usando C ao invés de C++).

3. a reprodução de algumas características de um determinado paradigma sobre outra linguagem que não a suporta pode ser útil para tornar o código mais manutenível (algumas bibliotecas em C, por exemplo, se beneficiam de características de OO para tornar o código manutenível, neste outro caso o autor utiliza OO em arquivos BAT do Windows, assim como outros exemplos, como OO em Shell Script).

Orientação a Objetos e C

Vamos discutir quais recursos da linguagem C podemos utilizar para emular a orientação a objetos. Existem alguns projetos open source que se beneficiam dessa emulação como design pattern:

• htop: visualizador de processos muito usado.
• GObject: usada pela biblioteca GTK+, a base de ambientes gráficos GNOME, Cinnamon, MATE, XFCE, e LXDE.
• Alguns padrões do kernel Linux.

Tem um livro onde o autor implementa alguns padrões de projeto da “Gangue dos 4” (originalmente pensados em C++) em C: https://leanpub.com/patternsinc.

O paradigma de orientação a objetos se sustenta sobre três pilares:

• Encapsulamento.
• Herança.
• Polimorfismo.

Basicamente, a ideia é emular esses pilares usando recursos da linguagem C como:

• structs opacas e ponteiros opacos como estruturas genéricas no código principal, e structs e ponteiros válidos somente no escopo de arquivo (válidos somente dentro de arquivos .c isolados do código principal) para emular encapsulamento de dados.
• structs aninhadas para emular herança.
• e ponteiros de função para emular polimorfismo.

Então, em resumo, uma “classe” em C será um arquivo .c dedicado a declarar uma struct que aglutinará “atributos privados” (membros da struct acessíveis somente no escopo do arquivo), “métodos” (ponteiros para funções para acesso aos membros da struct), “método construtor” (função responsável por alocar memória na heap e popular alguns membros da struct), e outras funções e variáveis internas do “objeto”.

Garbage Collector em C

No processo de compilação usaremos -lgc, no arquivo connection.c incluiremos o gc.h, e usaremos um malloc diferente chamado GC_malloc().

A libgc foi usada aqui para implementar um Garbage Collector (isso mesmo: garbage collector em C), com ela não será necessário usar free() para destruir nosso “objeto” instanciado.

Existem vários algoritmos diferentes de garbage collector (o Java, por exemplo, possui suporte a várias implementações de GC). A libgc (também chamada de Boehm-Demers-Weiser Garbage Collector) faz uso do tradicional Mark-and-Sweep.

Tá bom, vamos ver como fica

Para não ficar confuso, vamos ao seguinte código de exemplo de um cliente de rede. Mas antes duas coisas são importantes frisar:

1. o arquivo main.c não conhece o conteúdo do objeto connection (connection no escopo desse arquivo é uma struct opaca). Os acessos aos “métodos” do objeto ocorre através de artimética de ponteiros.
2. todo o arquivo connection.c seria a implementação da “classe” (não só a struct). E observe que a struct connection possui membros vistos apenas no escopo deste arquivo. Desta forma, a “classe” Connection poderá ser modificada sem o conhecimento de quem a chama (abstração).

Saída da execução

Código

Compila com: gcc main.c connection.c -o main -lgc

// main.c: Exemplo de C Orientado a Objeto
#include <stdio.h>
#include <stdlib.h>
#include "connection.h"

int main(int argc, char *argv[]) {
 Connection *connection;
 Data payload;

 connection = new_Connection(); // implementa uma espécie de "construtor"
 payload = (Data) "GET / HTTP/1.1";

 ((void (*)(Connection *, char *)) *((long int *) connection+0) ) (connection, "127.0.0.1"); // chama método setServer
 ((void (*)(Connection *, int))    *((long int *) connection+1) ) (connection, 80);          // chama método setPort
 ((void (*)(Connection *, int))    *((long int *) connection+2) ) (connection, 6);           // chama método setProtocol
 ((void (*)(Connection *, Data))   *((long int *) connection+3) ) (connection, payload);     // chama método setData
 ((void (*)(Connection *))         *((long int *) connection+4) ) (connection);              // chama método startConnection

 exit(0);
}

// connection.h: definição de dados abstratos
#ifndef CONNECTION_H__
#define CONNECTION_H__

#define TCP 6
#define UDP 17

typedef struct _connection Connection;
typedef void* Data;
Connection* new_Connection(void);

#endif

// connection.c: Exemplo de implementação da "classe" connection
#include <stdio.h>
#include <stdlib.h>
#include <gc.h>
#include "connection.h"

typedef void (*fpSetServer)(Connection*, char *);
typedef void (*fpSetPort)(Connection*, int);
typedef void (*fpSetProtocol)(Connection*, int);
typedef void (*fpSetData)(Connection*, Data *);
typedef void (*fpStartConnection)(Connection*);

struct _connection {
 fpSetServer setServer;
 fpSetPort setPort;
 fpSetProtocol setProtocol;
 fpSetData setData;
 fpStartConnection startConnection;

 char * serverIPv4;
 unsigned short int serverPort;
 short int serverProtocol;
 Data data;
};

void setServer(Connection* self, char *serverIPv4) {
 self->serverIPv4 = serverIPv4;
}

void setPort(Connection* self, int serverPort) {
 self->serverPort = serverPort;
}

void setProtocol(Connection* self, int serverProtocol) {
 self->serverProtocol = serverProtocol;
}

void setData(Connection* self, Data *data) {
 self->data = data;
}

void startConnection(Connection* self) {
 printf(" Server: %s\n", self->serverIPv4);
 printf(" Port: %d\n", self->serverPort);
 printf(" Protocol: %s\n", self->serverProtocol == 6? "TCP" : "UDP");
 printf(" Data: \"%s\"\n", (char *) self->data);
}

Connection* new_Connection(void) {
 Connection *obj;
 obj = (Connection *) GC_malloc(sizeof(Connection));

 obj->setServer       = setServer;
 obj->setPort         = setPort;
 obj->setProtocol     = setProtocol;
 obj->setData         = setData;
 obj->startConnection = startConnection;

 return obj;
}

Materiais interessantes

Além da já citada palestra do Hisham Muhammad, alguns outros materiais interessantes sobre esse assunto:

• Como programar em C Orientado a Objetos
• C Escondendo o conteúdo de structs com tipos incompletos
• Object-Oriented Techniques, Capítulo 8, livro Understanding and Using C Pointers
• A Fat Pointer Library