Programar em C é sempre divertido, principalmente se vc sabe o que faz. Um exemplo disso é como trabalhar com estruturas de dados complexas, ponteiros e casting.

Imaginem as duas estruturas abaixo:

typedef struct {
	int id;
	char name[128];
} tpessoa;
 
typedef struct {
	int id;
	char name[128];
	char rg[128];
} tpessoafisica;

Ok, tenho um tipo tpessoa e um tpessoafisica que representam um tipo básico (pessoa) e um tipo propositalmente extendido, especializado para algum fim (pessoa fisica). Posso ter um tipo para pessoa juridica, por exemplo.

Imagine que eu posso ter diversas operações com o tipo básico e, por acaso, quero utilizar também com o tipo extendido (tpessoafisica). Como fazer? Em algumas linguagens eu posso fazer isso:

tpessoafisica x = {...};
tpessoa y = (tpessoa) x;

Entretanto em C isso gera um erro de conversion to non-scalar type requested. Eu posso converter int para float, float para int, int para long, char para int, etc, mas conversão de estruturas não é bem por ai: até porque não existe uma clara noção do que deveria acontecer, certo?

Para isso temos que clamar pelo conceito de compatibilidade binária: Sendo duas estruturas de dados, A e B, se B especializa A de forma ter todos os mesmos atributos na ordem que foi definida em A (e, opcionalmente, alguma coisa a mais no final), eu posso fazer um cast de um ponteiro do tipo B para um ponteiro do tipo A.

Vejamos, o tpessoafisica tem no começo os mesmos atributos (id e name) que a tpessoa e, por acaso, tem um atributos rg a mais no final. Dessa forma eu posso fazer o cast dos ponteiros na ordem apropriada.

void mostra_pessoa(tpessoa *x){
	printf("Pessoa { id = %d, name = %s }\n",x->id,x->name);
}
 
int main(){
	tpessoafisica x = {100, "pacman", "666"};
	// cast vale para ponteiros, por isso uso o operador &
	mostra_pessoa((tpessoa *) &x);
	return 0;
}

Ou seja, mostra pessoa esta preparado para receber um ponteiro do tipo tpessoa mas, graças a um habil cast de ponteiros aproveitando o principio de compatibilidade binária eu posso passar o endereço de uma estrutura diferente, no caso de tpessoafisica.

Perceba que eu preciso de um cast entre ponteiros, por isso eu preciso apelar para um & na frente da variavel, pegando o endereço de memória associado aquela variavel. Este recurso é util em muitas situações, desde simular interfaces e herança até coisas mais divertidas como fazer perl 5.x rodar perl 6.

Hoje em dia é raro um desenvolvedor conhecer bem apenas uma linguagem. Em nome da multidisciplinaridade, decidi mostrar algums exemplos do mesmo programa: uma classe HelloWord com um construtor que recebe uma mensagem (“ola mundo”) e um método show() que imprime essa mensagem.

Vejamos um exemplo em C++

#include <iostream>#include <string>using namespace std;

class HelloWorld{        string mensagem;        public:        HelloWorld(string mensagem) { // construtor!                this->mensagem = mensagem;        }

        void show() { // metodo show                cout << "mensagem: " << this->mensagem << endl;        }};int main(){        HelloWorld obj("ola mundo");        obj.show();        return(0);}

Agora o mesmo código em Java:

package Hello;

public class HelloWorld{        private String mensagem;        public HelloWorld(String mensagem){                 this.mensagem = mensagem;        }        public void show() {                 System.out.println("mensagem: " + mensagem);        }        public static void main(String [] args){                HelloWorld obj = new HelloWorld("ola mundo");                obj.show();        }}

Agora, percebam a simplicidade do Ruby:

class HelloWorld        def initialize(mensagem)                @mensagem = mensagem         end        def show                 puts "mensagem: #{@mensagem}"        endend

obj = HelloWorld.new "ola mundo"obj.show

Agora em Perl (sim, Perl!)

package HelloWorld;

sub new{        my ($class, $mensagem) = @_;        my $self = {  mensagem => $mensagem  };        bless $self, $class; # abençoando a variavel!        return $self;}

sub show{        my $self = shift; # sim, ela vem como argumento!        print "mensagem: " . $self->{mensagem} . "\n";}

my $obj = new HelloWorld("ola mundo");$obj->show(); # parece artificial, não?

1;

PHP também é:

<?php

Class HelloWorld{        var $mensagem = "";        function HelloWorld($mensagem){                $this->mensagem = $mensagem;        }        function show(){                echo "mensagem : " . $this->mensagem . "<br/>";        }}

$obj = new HelloWorld("ola mundo");$obj->show();?>

Por fim, vamos criar um tipo usando JavaScript

function HelloWorld(mensagem){        this.mensagem = mensagem;        this.show = function(){                alert("mensagem: " + this.mensagem);        }}

var obj = new HelloWorld("ola mundo");obj.show();

Edit: Python, atendendo a diversos pedidos

class HelloWorld:    def __init__(self, arg):        self.message = arg

    def show(self):        print "mensagem: ", self.message

hello = HelloWorld("Ola Mundo")hello.show()

A diferença entre uma linguagem e outra está (entre outras coisas) na sintaxe: em Perl eu tenho que criar os mecanismos na mão (com bless e receber $self) mas em Java e Ruby é tudo muito natural. Em Javascript eu não tenho uma construtor propriamente dito (muito menos classes) mas uma função (e crio um objeto dando um new nessa função).

Vou abordar o tema “herança” no proximo post, espero que seja útil