O make (GNU make) é uma ferramenta que executa os comandos inclusos dentro de um arquivo. É normalmente utilizado na compilação e instalação de programas.

Uma das vantagens do make é que ele identifica quais partes do programa devem ser recompiladas de acordo com as mudanças efetuadas desde a última compilação.

Dependendo do tamanho do programa pode-se economizar minutos ou horas entre as recompilações, pois não será necessário recompilar o programa inteiro.

Exemplo de uso:

$ make -f arquivo_com_os_comandos

Se você chamar o comando make sem passar nenhum parâmetro ele tentará utilizar o arquivo com nome de Makefile do diretório atual.

É o que normalmente acontece quando você precisa compilar e instalar um programa pelo código fonte.

• Descompactar o código fonte (se for um "*.tar.gz").
• Entrar na pasta descompactada. Haverá um arquivo Makefile dentro.
• Executar o comando "make" para compilar.
• Executar o comando "make install" como root para instalar.

Makefile

Se você quiser utilizar o comando make só é necessário criar um arquivo Makefile e dentro dele colocar as instruções que o make deve executar.

Formato do Makefile:

regra: dependências...
	comandos
	...

Os comandos são comandos normais do shell (bash). Pode-se colocar vários comandos, porém devem estar identados com tabulações. Isto é importante, não utilize espaços pois não irá funcionar.

A regra é só um nome para identificar um bloco de comandos. Fazendo uma analogia com programação, a "regra" seria semelhante a uma função.

As dependências são os arquivos necessários para a execução dos comandos da regra, o make irá fazer a verificação deles. Também podem ser outras regras que serão chamadas antes da execução dos comandos. Se houver mais de uma dependência elas devem ser separadas com espaços.

Aqui vai um exemplo de um Makefile que compila um programa em C:

program:
	gcc -o meuprograma meuprograma.c

Um exemplo com dependências:

program: cod1.c cod2.c lib1.a
	gcc -c cod1.c cod2.c
	gcc cod1.o cod2.o lib1.a -o program

lib1.a: lib1.c cod3.c
	gcc -c lib1.c cod3.c
	ar rcs lib1.a lib1.o cod3.o
	ranlib lib1.a

Pode-se utilizar variáveis também. A declaração é simples, mas devem ser chamados com a notação "$(variável)". Repare também que elas podem ser concatenadas:

CC=gcc
CFLAGS=-O2
CFLAGS=$(CFLAGS) -Wall

program:
	$(CC) $(CFLAGS) -o program program.c

Olha que legal no Makefile a seguir, advinha o que acontece ao executar o comando `make clean' no terminal?

program: program.c
        gcc -o program program.c

clean:
        rm *.o
        rm program

O que aconteceria também se houvesse um arquivo no diretório atual que se chamasse "clean"? O `make clean' não iria executar a lista de comandos da regra. Para evitar este tipo de conflito utilize a regra ".PHONY":

program: program.c
        gcc -o program program.c

.PHONY: clean
clean:
        rm *.o
        rm program

Agora a regra "clean" será executada mesmo se houver um arquivo no diretório atual com mesmo nome.

float a = 1.0;
int b = (int) a;  // cast

Para transformar um número em ponteiro é a mesma coisa, a diferença é que para ler a memória byte-a-byte o ponteiro deve ser um “char”. Por exemplo, um “(char*) 255” irá converter 255 para um ponteiro que aponta para o endereço 0xFF.

Mas nós só convertemos para ponteiro, para ler o conteúdo ainda é necessário colocar um “*” antes do ponteiro, como se faz normalmente para se ler o conteúdo de um ponteiro normal. Como é um ponteiro do tipo “char” o seu retorno pode ser exibido na tela.

Abaixo segue um programa que pede para o usuário digitar um endereço de memória em hexadecimal e quantidade de bytes que devem ser lidos, em seguida ele exibe o conteúdo da memória.

#include<iostream>
#include<sstream>
 
using namespace std;
 
// Funcao para exibir apenas caracteres imprimiveis
char ChangeToPrintable(char C)
{
    return ((C < 32) || (C > 126))?'?':C;
}
 
int main(int argc, char** argv)
{
    unsigned long addr_i, i, len;
    string addr_str;
 
    cout<<"Endereço de memória em hex.: ";
    cin>>addr_str;
 
    cout<<"Quantidade de bytes: ";
    cin>>len;
 
    cout<<endl;
 
    // Converte a string hex. em inteiro
    stringstream convert(addr_str);
    convert>>hex>>addr_i;
 
    for(i = addr_i; i < (addr_i + len); i++)
    {
        cout<<ChangeToPrintable(*((char*) i));
    }
 
    cout<<endl;
 
    return 0;
}

O interessante sobre o programa é que se ele rodar irá exibir um “segmentation fault”. Isso está correto, porque o sistema operacional não deve permitir que um programa leia (invada) a memória de outro. Mas você pode ler a memória alocada para o próprio programa que está rodando. Você pode tentar, por exemplo, ler a partir da área onde a função “main” está alocada, colocando o seguinte código antes do “for” que realiza a leitura dos dados:

addr_i = (unsigned long) &main; // Converte o endereço para inteiro

Introdução
Imagine que seu professor de linguagem C++ (ou outra de sua preferência, mas uma linguagem descente, por favor) lhe passe uma lição de casa: “Faça um MMORPG em 5 idiomas diferentes”.
Simples não? Qualquer um faz um MMORPG em C++ da noite para o dia. O detalhe desta simples aplicação é permitir a utilização ou diversão (já que é um game) em outros idiomas.
Se você pensou em um colocar vários “IFs” ou “CASEs” para cada linha que contenha uma string...

Bom, talvez não seja algo tão errado, se você tiver tempo para colocar vários “IFs” para cada uma das 4.000 strings de frases aleatórias dos NPCs do seu game. O trabalho todo será seu mesmo.
Tudo bem, é só uma lição de casa, mas se não for pegue suas coisas e passe no RH (ou passe no RH e depois pegue as suas coisas... vocês entenderam né?).

Bom, sem encher muita lingüiça, vamos ao ponto: i18n

What?
i18n é o acrônimo de internacionalization (“i” + 18 letras + “n”). As vantagens de se utilizar i18n são:

- O programa não precisa ser re-compilado a cada alteração nas traduções. Alternar entre os idiomas pode ser feito dinamicamente em tempo de execução (salvo algumas situações específicas).

- Este método é válido para muitas linguagens, não só o C++, o processo é praticamente o mesmo.

- Se o programa não conseguir encontrar a string traduzida ele exibirá a string original.

- A pessoa que fará as traduções não precisa entender de programação. Como o arquivo a ser traduzido está separado do programa, você pode mandar para um tradutor e depois só fazer as modificações necessárias para encaixar no programa (poucas coisas mesmo).

- Seu amigo chinês vai poder jogar seu game! De quebra ele indica o seu game para outros amiguinhos chineses que devem ser mais ou menos uns 10 mil só no bairro dele.

- Formatação correta de moeda, pesos, medidas, data, hora, etc. para o idioma escolhido.

- Aumento do alcance do seu programa/game em escala mundial. Para um alemão, nada melhor do que se utilizar um software em alemão. Para um brasileiro, nada melhor do que utilizar um software em português, não é?

- Perdão. Não existe nada melhor do que utilizar um software em português brasileiro (ora pois!).

- E outros benefícios que eu não me lembro ou não consegui inventar.

Nada mastigado, apenas o caminho das pedras...
Mas como utilizar a/o i18n em meu programa? A melhor forma é utilizando o gettext. Seu uso é relativamente simples (claro, se você for um programador de verdade). Os passos e quesitos básicos para implementar as traduções são:

- O programa para estar perfeitamente internacionalizado deve ter suporte a caracteres UNICODE, mas tem que ter suporte de verdade ao UNICODE. Por exemplo, no Delphi só é possível manipular esses caracteres internamente sem poder exibi-los, pois os componentes dele não possuem suporte ao UNICODE (e vai saber quando terá de verdade). Mas você pode comprar componentes de terceiros com suporte a UNICODE, ou fazer que nem eu que alterei o componente TEdit na mão e fez o antivírus apitar na hora de rodar o programa (depois eu conto essa história).

- Instalar o gettext se você não tiver.

- Marcar no código as strings que serão traduzidas. Por exemplo:

printf("Welcome to the Django Mr. %s!\n", name);

se transforma em:

printf(_("Welcome to the Django Mr. %s!\n"), name);

onde “_()” é uma função do gettext que marca a string para extração. Esta talvez seja a parte chata da coisa, mas não é tanto esforço assim.

- Um botão ou opção no seu programa para o usuário mudar o idioma.

- Extrair as strings (veja o manual do gettext). Será gerado um arquivo *.po com as strings marcadas.

- Traduzir as strings para um idioma em um editor de texto UNICODE. Utilizando o exemplo anterior ficaria assim:
"Welcome to the Django Mr. %s!\n"
"Bem-vindo a Djelva Sr. %s!\n"

- Compilar o arquivo traduzido com uma ferramenta apropriada, será gerado um arquivo *.mo. Uma ferramenta que utilizo para compilar e editar é o Poedit.

- Copiar o arquivo compilado para a pasta correta, normalmente (ou sempre) é em “diretório_do_programa/locale/sigla_do_idioma/LC_MESSAGES/default.mo”. Como em “meu_programa_bilingue/locale/pt_BR/LC_MESSAGES/default.mo”. Agora você sabe por que alguns programas com vários idiomas possuem uma pasta “locale” no diretório de instalação?

- Testar o seu programa.

- Para alterar a tradução basta editar apenas o *.po do idioma e compila-lo novamente, sem precisar mexer no código fonte do programa.

Basicamente, para cada idioma haverá um arquivo compilado diferente. De preferência, o idioma original do seu programa deve estar em inglês, mas nada impede que você o faça em português.

Dicas
- Ao fazer a tradução procure fazer com que a tradução possua um tamanho próximo ao do original.

- No caso do Delphi você pode utilizar o dxgettext, ele faz a captura automática das strings dos componentes. Infelizmente, faça uma boa leitura da documentação dele, pois existem alguns atributos de componentes que não devem ser traduzidos.

- Antes de fazer o seu programa estude (é estude!) um pouco sobre os idiomas que você irá disponibilizar em seu programa. Dependendo do idioma será necessário colocar algumas alterações no programa, como a escrita da direita-para-esquerda, de cima-para-baixo, etc. Não é nada muito difícil de fazer, muitas vezes isso é feito de forma automática pelo programa (depende muito da API utilizada) ou só mudar uma flag do componente que está utilizando (que também depende muito da API utilizada XD).

- Permita que o usuário escolha o idioma. Não obrigue ele a utilizar somente o idioma definido pelo SO. Eu mesmo já sofri muito com isso. :´(

- Para aplicações Desktop o ideal é que o texto possa fluir na tela de forma dinâmica, pois um texto pode aumentar ou diminuir de dimensões ao mudar de idioma, como de "texto romanizado" para "ideogramas chineses". Faça com que os itens da tela se redimensionem e se posicionem automaticamente. Uma boa opção é deixar com quebras de linhas automáticas, tomando o cuidado para que o texto não fique em cima de outros itens ao quebrar a linha.

Repare que só é possível fazer essas traduções com textos estáticos do programa. Se vierem dados do banco de dados já é mais complicado. A não ser que suas tabelas estejam bem modeladas, pelo menos na 3NF já daria para traduzir boa parte dos campos. Por exemplo, uma tabela de cores poderia ter os campos “cor_ptbr” e “cor_en”. Mas como fazer traduções corretamente de banco de dados isso eu deixo para próxima (pois nem eu sei XD).

Não entendeu nada do que falei? Clique aqui que tudo ficará mais claro.

Sockets são importantes, por isso eu tinha que tomar vergonha na cara e aprender a usá-los, comecei a ler sobre o assunto e consegui fazer uma pequena aplicação que envia mensagens para outra.

Primeiramente vou mostrar o código e depois ir (tentando) descrever as funções. Não vou me aprofundar, é só para ter uma idéia de como a coisa funciona, mesmo porque eu acho que aprofundei demais na explicação (mas quanto mais se sabe, mas se sabe que não se sabe nada XD).

O código foi feito para Windows, mas a implementação no Linux é bem parecida. No Windows você deve usar a WinSock API para trabalhar com sockets, não se esqueça de linkar a lib na hora de compilar. Eu uso o Dev-C++ e a lib é a libwsock32.a.

Criando o servidor que recebe mensagens

/*
    SERVIDOR
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock.h>
 
#define BACKLOG_MAX 5
#define BUFFER_SIZE 128
#define EXIT_CALL_STRING "#quit"
 
int local_socket = 0;
int remote_socket = 0;
 
int remote_length = 0;
int message_length = 0;
 
unsigned short local_port = 0;
unsigned short remote_port = 0;
 
char message[BUFFER_SIZE];
 
struct sockaddr_in local_address;
struct sockaddr_in remote_address;
 
WSADATA wsa_data;
 
/* Exibe uma mensagem de erro e termina o programa */
void msg_err_exit(char *msg)
{
    fprintf(stderr, msg);
    system("PAUSE");
    exit(EXIT_FAILURE);
}
 
int main(int argc, char **argv)
{
    // inicia o Winsock 2.0 (DLL), Only for Windows
    if (WSAStartup(MAKEWORD(2, 0), &wsa_data) != 0)
        msg_err_exit("WSAStartup() failed\n");
 
    // criando o socket local para o servidor
    local_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (local_socket == INVALID_SOCKET)
    {
        WSACleanup();
        msg_err_exit("socket() failed\n");
    }
 
    printf("Porta local: ");
    scanf("%d", &local_port);
    fflush(stdin);
 
    // zera a estrutura local_address
    memset(&local_address, 0, sizeof(local_address));
 
    // internet address family
    local_address.sin_family = AF_INET;
 
    // porta local
    local_address.sin_port = htons(local_port);
 
    // endereco
    local_address.sin_addr.s_addr = htonl(INADDR_ANY); // inet_addr("127.0.0.1")
 
    // interligando o socket com o endereço (local)
    if (bind(local_socket, (struct sockaddr *) &local_address, sizeof(local_address)) == SOCKET_ERROR)
    {
        WSACleanup();
        closesocket(local_socket);
        msg_err_exit("bind() failed\n");
    }
 
    // coloca o socket para escutar as conexoes
    if (listen(local_socket, BACKLOG_MAX) == SOCKET_ERROR)
    {
        WSACleanup();
        closesocket(local_socket);
        msg_err_exit("listen() failed\n");
    }
 
    remote_length = sizeof(remote_address);
 
    printf("aguardando alguma conexao...\n");
    remote_socket = accept(local_socket, (struct sockaddr *) &remote_address, &remote_length);
    if(remote_socket == INVALID_SOCKET)
    {
        WSACleanup();
        closesocket(local_socket);
        msg_err_exit("accept() failed\n");
    }
 
    printf("conexao estabelecida com %s\n", inet_ntoa(remote_address.sin_addr));
    printf("aguardando mensagens...\n");
    do
    {
        // limpa o buffer
        memset(&message, 0, BUFFER_SIZE);
 
        // recebe a mensagem do cliente
        message_length = recv(remote_socket, message, BUFFER_SIZE, 0);
        if(message_length == SOCKET_ERROR)
            msg_err_exit("recv() failed\n");
 
        // exibe a mensagem na tela
        printf("%s: %s\n", inet_ntoa(remote_address.sin_addr), message);
    }
    while(strcmp(message, EXIT_CALL_STRING)); // sai quando receber um "#quit" do cliente
 
    printf("encerrando\n");
    WSACleanup();
    closesocket(local_socket);
    closesocket(remote_socket);
 
    system("PAUSE");
    return 0;
}

WSAStartup()

A função WSAStartup() inicia o Windows Sockets Dynamic Link (WinSock DLL). Ela também é usada para confirma a versão do WinSock DLL. Estamos utilizando a 2.0.

Declaração:

int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);

O parâmetro wVersionRequested é número da maior versão que a aplicação pode usar. Repare que ele é uma WORD onde o byte de maior ordem especifica a número da minor version e o byte de ordem menor indica a major version. Por isso eu utilizo a função MAKEWORD para retornar uma WORD (e facilitar minha vida), por exemplo, se quiser usar a versão do WinSock 1.1 é só alterar para MAKEWORD(1, 1). Fácil demais...

O parâmetro lpWSAData é um ponteiro para um estrutura WSADATA que receberá os detalhes da implementação do WinSock.

Se der tudo certo a função retornará 0. Se ocorrer um erro você pode usar a função WSAGetLastError() para saber mais detalhes.

socket()

Use a função socket() parar criar o socket \o/.

Declaração:

SOCKET WSAAPI socket(int af, int type, int protocol);

O parâmetro af especifica o "address family" que este socket usa. Nós iremos usar o AF_INET. A versão 1.1 do WinSock só suporta o formato AF_INET.

Alguns formatos possíveis:
AF_INET: Arpa Internet Protocols
AF_UNIX: Unix Internet Protocols
AF_ISSO: Iso Protocols
AF_NS: Xerox Network System Protocols

Se você olhar no header (winsock.h) vai encontrar outros como o AF_FIREFOX, mas é melhor ver quais realmente podem ser usados no MSDN.

O parâmetro type especifica o tipo do socket, no nosso caso é SOCK_STREAM (utilizado na maioria dos programas), mas você pode usar o SOCK_DGRAM (UDP), mas não vou abordar as diferenças entre eles.

Em protocol deixe 0 (zero), isto indica que o socket irá usar o valor padrão. O protocol pode ser o padrão porque a combinação do AF_INET+SOCK_STREAM já indica que o protocolo é TCP. Eu coloquei IPPROTO_TCP no código, mas não precisa, é só deixar como 0.

Alguns valores possíveis para o protocol:
IPPROTO_IP: Internet Protocol (0)
IPPROTO_ICMP: Internet Control Message Protocol (1)
IPPROTO_IGMP: Internet Group Multicast Protocol (2)
IPPROTO_GGP: Gateway-Gateway Protocol (3)
IPPROTO_TCP: Transmission Control Protocol (6)
IPPROTO_UDP: User Datagrama Protocol (17)

Se der tudo certo a função irá retornar o socket descriptor, que é um número que identifica o socket criado. Se falhar irá retorna INVALID_SOCKET, você pode usar a função WSAGetLastError() para saber mais detalhes do erro.

bind()

Agora precisamos dar nomes aos bois, precisamos dizer que o nosso socket se chama "192.168.0.1", por exemplo. Usaremos a função bind() para isso.

Declaração:

int bind(SOCKET s, const struct sockaddr *addr, int namelen);

O parâmetro s é o socket descriptor retornado pela função socket(). O parâmetro addr é um ponteiro para uma estrutura do tipo sockaddr. O namelen é o tamanho em bytes da estrutura, use a função sizeof() para isto.

Esta parte pode confundir, antes de usar a função bind() nós precisamos conhecer as estruturas sockaddr, sockaddr_in e in_addr, mas a que iremos utilizar é a sockaddr_in.

Definições da estrutura sockaddr:

struct sockaddr
{
    u_short sa_family; // address family
    char sa_data[14]; // address
};

O item sa_data da estrutura vai depende do "address family". No WinSock 1.1, como eu disse, apenas o AF_INET é suportado, logo somente um "endereçamento de internet" é suportado no sa_data. Lembrando que você não vai utilizar esta estrutura, mas eu coloquei porque ela aparece em um "cast" de um dos parâmetros da função bind() que estamos utilizando. Você deve utilizar uma outra estrutura no lugar da sockaddr quando chamar a função bind(), use a sockaddr_in.

Definições da estrutura sockaddr_in:

struct sockaddr_in
{
    short sin_family; // address family
    u_short sin_port; // port
    struct in_addr sin_addr; // internet address
    char sin_zero[8]; // to make a beautiful cast
};

Primeiro você deve zerar a estrutura e depois preencher alguns itens. No código que eu fiz está assim:

struct sockaddr_in local_address;
/* ... */
memset(&local_address, 0, sizeof(local_address)); // zera a estrutura
 
local_address.sin_family = AF_INET;
local_address.sin_port = htons(local_port);
local_address.sin_addr.s_addr = htonl(INADDR_ANY);

Importante!
Nem todos os computadores armazenam os dados na mesma ordem na memória. Existem computadores que trabalham no formato "Big Endian", onde byte menos significativo fica no endereço de memória de maior valor. Por exemplo, para armazenar o número 0x01234567 ficaria assim:
endereço 0x101: 01
endereço 0x102: 23
endereço 0x103: 45
endereço 0x104: 67

O maior endereço é o 0x104 e o byte menos significativo de 0x01234567 é o último da direita (67).

Já nos computadores "Little Endian", ocorre o inverso, o byte menos significativo fica no endereço de memória de menor valor:
endereço 0x101: 67
endereço 0x102: 45
endereço 0x103: 23
endereço 0x104: 01
O menor endereço é o 0x101 e o byte menos significativo de 0x01234567 é o último da direita (67).

Os computadores com processadores baseados no Intel x86 são "Little Endian", mas a ordem dos bytes na rede (network) é "Big Endian". Precisamos converter os dados antes de enviá-los usando as funções htons() e htonl():
htons(): converte um unsigned short (host-to-network)
htonl(): converte um unsigned long (host-to-network)

Existem outras funções para esta converter os dados, mas nós iremos utilizar apenas esses.

Voltando a estrutura sockaddr_in, vamos falar do item sin_addr. Veja na declaração que este item é uma estrutura do tipo in_ddr.

Definições da estrutura in_addr:

struct in_addr
{
    union
    {
        struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
        struct { u_short s_w1,s_w2; } S_un_w;
        u_long S_addr;
    } S_un;
    #define s_addr S_un.S_addr
    #define s_host S_un.S_un_b.s_b2
    #define s_net S_un.S_un_b.s_b1
    #define s_imp S_un.S_un_w.s_w2
    #define s_impno S_un.S_un_b.s_b4
    #define s_lh S_un.S_un_b.s_b3
};

Repare nos defines que ela possui, você pode acessar o dados da estrutura através deles. Quando você acessa local_address.sin_addr.s_addr na verdade esta acessando local_address.sin_addr.S_un.S_addr. Mas sempre use os defines para manter compatibilidade, não acesse os dados diretamente.

O valor indicado para local_address.sin_addr.s_addr é htonl(INADDR_ANY), isto indica que usaremos todos os endereços locais designados ao nosso servidor. Por exemplo, se sua máquina possui duas placas de rede (192.168.0.1 e 192.168.0.2), você pode usar os dois endereços para o seu socket. Mas se você quiser especificar apenas uma placa, use a função inet_addr(). Nós usaremos esta função para fazer o programa cliente.

Sobre o item sin_zero da estrutura sockaddr_in, ele server apenas para ocupar espaço, de modo que a estrutura tenha o mesmo tamanho (em bytes) da estrutura sockaddr. Assim podemos fazer "casts" de uma estrutura para outra (utilizado no parâmetro da função bind()). Por isso a estrutura deve ser preenchida com zeros antes de ser utilizada.

Se der tudo certo a função bind() retornará 0, caso contrário retornará SOCKET_ERROR, use o WSAGetLastError() para analisar o erro.

listen()

A função listen() coloca o socket para escutar as conexões. Seria como ligar o socket, agora ele pode receber por conexões dos clientes.

Declaração:

int listen(SOCKET s, int backlog);

O parâmetro s é o socket descriptor que você já conhece. O backlog indica quantas conexões pendentes o socket pode deixar na fila para serem processadas, quando as conexões são aceitas elas são removidas da fila. O mínimo para o backlog é 1 e o máximo 5, mas não achei alguma coisa no site do MSDN que indicasse que o limite é sempre 5.

Se tudo der certo ele vai retornar 0, caso contrário ele retornará um SOCKET_ERROR. Novamente você pode usar a função WSAGetLastError() para analisar o erro se quiser.

accept()

O accept() aceita a conexão quando ela é detectada.

Declaração:

SOCKET accept(SOCKET s, struct sockaddr* addr, int* addrlen);

O parâmetro s é o socket descriptor. O parâmetro addr é um ponteiro para uma estrutura do tipo sockaddr (igual ao do função bind()), nela a função irá armazenar a o endereço (estrutura) da entidade (cliente) que requisitou a conexão. Você não precisa armazenar este valor se não quiser obter informações do cliente, pode colocar apenas um NULL no lugar.

O parâmetro addrlen é um ponteiro onde a função irá colocar o tamanho em bytes da estrutura addr recebida do cliente. Se você passar um NULL para o parâmetro addr então o addrlen retornará NULL para o ponteiro. Você também pode apenas colocar um NULL no parâmetro do addrlen.

Repare que o programa ficará esperando por uma conexão, ele ficará meio travado enquanto isso. Você terá que fazer ele rodar de forma assíncrona, mas isso não é importante agora, primeiro temos que fazer o servidor e o cliente funcionarem.

A função accept() irá retornar um socket descriptor do cliente. Se der algum problema será retornado um INVALID_SOCKET. Novamente use o WSAGetLastError() para verificar os erros.

recv()

O recv() recebe os dados de uma conexão.

Declaração:

int recv(SOCKET s, char* buf, int len, int flags);

O parâmetro s é o socket descriptor do cliente. O parâmetro buf é o buffer onde serão armazenadas as informações recebidas. O len é o tamanho deste buffer.

O parâmetro flags indica o modo como serão recebidos os dados, eu deixei como 0 (zero) assim ele não fará nenhuma ação especial. Para mais detalhes sobre outras opções olhe no site MSDN.

O recv() irá retornar o total de bytes recebidos, mas você não irá receber mais bytes do que especificou em len. Ele retorna 0 (zero) quando a conexão é fechada normalmente. Se der algum erro ele retorna um SOCKET_ERROR. Use o WSAGetLastError() para saber mais do erro.

Repare que eu também usei a função inet_ntoa() para exibir junto com a mensagem. Essa função converte um endereço de Internet (IPv4) em uma string do endereço formatado nos padrões de Internet com pontos decimais. Ela já retorna em "Little Endian".

O recv() está dentro de um loop, antes de receber uma mensagem o buffer (variável message no código) deverá ser limpo. Após receber a mensagem, ela é exibida. O loop só pára quando o cliente enviar uma mensagem "#quit". Não é a melhor maneira de ser terminar o programa, mas serve por enquanto.

Depois de tudo pronto, nós devemos finalizar a aplicação com as funções WSACleanup() e closesocket(). Você só precisa olhar o código para entender como usa-las. E é isso, o micro-nano-humilde-servidor tá pronto agora só falta fazer o cliente.

Criando cliente que envia as mensagens

/*
    CLIENTE
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock.h>
 
#define BUFFER_SIZE 128
#define EXIT_CALL_STRING "#quit"
 
int remote_socket = 0;
int message_length = 0;
 
unsigned short remote_port = 0;
 
char remote_ip[32];
char message[BUFFER_SIZE];
 
struct sockaddr_in remote_address;
 
WSADATA wsa_data;
 
/* Exibe uma mensagem de erro e termina o programa */
void msg_err_exit(char *msg)
{
    fprintf(stderr, msg);
    system("PAUSE");
    exit(EXIT_FAILURE);
}
 
int main(int argc, char **argv)
{
    if (WSAStartup(MAKEWORD(2, 0), &wsa_data) != 0)
        msg_err_exit("WSAStartup() failed\n");
 
    printf("IP do servidor: ");
    scanf("%s", remote_ip);
    fflush(stdin);
 
    printf("Porta do servidor: ");
    scanf("%d", &remote_port);
    fflush(stdin);
 
    remote_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (remote_socket == INVALID_SOCKET)
    {
        WSACleanup();
        msg_err_exit("socket() failed\n");
    }
 
    // preenchendo o remote_address (servidor)
    memset(&remote_address, 0, sizeof(remote_address));
    remote_address.sin_family = AF_INET;
    remote_address.sin_addr.s_addr = inet_addr(remote_ip);
    remote_address.sin_port = htons(remote_port);
 
    printf("conectando ao servidor %s...\n", remote_ip);
    if (connect(remote_socket, (struct sockaddr *) &remote_address, sizeof(remote_address)) == SOCKET_ERROR)
    {
        WSACleanup();
        msg_err_exit("connect() failed\n");
    }
 
    printf("digite as mensagens\n");
    do
    {
        // limpa o buffer
        memset(&message, 0, BUFFER_SIZE);
 
        printf("msg: ");
        gets(message);
        fflush(stdin);
 
        message_length = strlen(message);
 
        // envia a mensagem para o servidor
        if (send(remote_socket, message, message_length, 0) == SOCKET_ERROR)
        {
            WSACleanup();
            closesocket(remote_socket);
            msg_err_exit("send() failed\n");
        }
    }
    while(strcmp(message, EXIT_CALL_STRING)); // sai quando enviar um "#quit" para o servidor
 
    printf("encerrando\n");
    WSACleanup();
    closesocket(remote_socket);
 
    system("PAUSE");
    return 0;
}

Essa parte vai ser mais rápida, pois já vimos o básico sobre sockets no servidor.

Você deve criar um socket no cliente para poder conectar ao servidor. Ele precisa preencher uma estrutura do tipo socketaddr_in (que nós já vimos) com as informações do servidor, olhe o código para entender melhor.

connect()

A função connect() irá conectar o cliente com o servidor.

Declaração:

int connect(SOCKET s, const struct sockaddr* name, int namelen);

Ele recebe parâmetros iguais ao da função bind(). Se der algum erro ele retorna um SOCKET_ERROR.

A função connect() tem o mesmo problema da função accept(), enquanto ele estiver tentando conectar ficará travado (precisa ser assíncrono), mas não vou mostra como se faz isso, fica como lição de casa XD.

send()

E o send() é a função responsável por enviar informações ao servidor.

Declaração:

int send(SOCKET s, const char* buf, int len, int flags);

Os parâmetro que ele recebe também são iguais ao da função recv(). O send() retonará o número de bytes enviados, esse número não será maior do len (e ele não enviará mais o que o especificado em len). Se der um erro ele retornará SOCKET_ERROR. Use o WSAGetLastError() para mais informações.

Lembre-se de limpar o buffer de mensagens, senão você irá enviar "lixo" para o servidor.

Pronto!

Compile os dois programas, depois execute primeiro o servidor depois o cliente. Se estiver rodando na mesma máquina você pode conectar o cliente no IP "127.0.0.1" que dará no mesmo. E é só isso, fácil demais não?

Para saber mais informações sobre o WinSock visite a página de referência da MSDN em Winsock Reference.

int soma_int(int a, int b)
{
    return (a + b);
}
 
float soma_float(float a, float b)
{
    return (a + b);
}
 
soma_int(10, 20); // retorna 30
soma_float(10.12, 20.34); // retorna 30.46

Com os templates é possível criar uma única função que some estes números mesmo que sejam de tipos diferentes de dados.
Basicamente para se criar uma função template é preciso ter a seguinte sintaxe:

template <class identificador> declaração_da_função;

Utilizando o template no código anterior ele ficaria assim:

template <class T>
T soma(T a, T b)
{
    return (a + b);
}
 
soma<int> (10, 20) // retorna 30
soma<float> (10.12, 20.34); // retorna 30.46

O código ficou menor, pois eu só precisei criar uma função. Com uma explicação bem tosca eu poderia dizer que o compilador troca todos os "T" da função template pelo que estiver entre os sinais de maior e menor na hora que você chama a função (soma<int>, soma<float>). É parecido com o define, porém os templates possuem checagem de tipagem de dados, são bem mais versáteis e evitam que se cometam erros bobos com o uso de defines em excesso.

Se os parâmetros da função são de apenas 1 tipo não é necessário especificar com o <int> ou <float>, o compilador já deduz o tipo:

soma(10, 20) // OK, os dois parâmetros são int
soma(10.12, 20.34); // OK, os dois parâmetros são float
soma(10, 20.34) // ERROR, os dois parâmetros são de tipos diferentes

Você também pode especificar mais tipos para o template:

template <class TValue, class TPercent, class TReturn>
TReturn get_percentage(TValue value, TPercent percentage)
{
    return (TReturn)(value * (percentage / 100.0));
}
 
get_percentage<int, float, int>(1000, 80.33) // retorna 80.33% de 1000 como int (803)
get_percentage<int, float, float>(1000, 80.33) // retorna 80.33% de 1000 como float (803.3)

Para deixar claro: "função<tipo1, tipo2, tipoN> (...);" corresponde a "template <class tipo1, class tipo2, class tipoN...> função(...);".

É possível utilizar os templates em classes também:

template <class T>
class my_class
{
  private:
    T attr;
  public:
    my_class (T value)
    {
        attr = value;
    }
};
 
my_class<int> object(1); // instânciando

Fiz uma explicação bem simples sobre o uso de templates, mas existem mais coisas que você deve aprender jovem Padawan. Recomendo uma lida aqui cplusplus.com e aqui Universal Knowledge Center About Everything.

Sem um controle seu jogo irá processar os gráficos na velocidade do processador. Os computadores tem velocidades diferentes e as aplicações não tem um processamento constante e igual, seu jogo poderá rodar a 124 FPS, mas se mexer o mouse irá para 81 FPS, por exemplo.

Antes de continuar você tem que conhecer o básico de como criar uma janela usando a Win32 API. Terá que usar também o PeekMessage ao invés do GetMessage no loop que pega os eventos (mensagens).

Agora vamos a lógica da coisa, você tem que "pausar" esse loop em determinados intervalos, por exemplo, se quiser 60 FPS terá que pausar 60 vezes por segundo de modo que no final a soma dos intervalos atinja 1 segundo. Para pausar use o Sleep, porém ele trabalha em milisegundos, mas é só dividir 1000.0 (milisegundos) por 60.0 (FPS).

Sleep(16.66);
// ou
Sleep(1000.0/60.0);

Pronto! Rápido e prático que nem miojo.

Agora se for um jogo pesado você terá que levar em contar o tempo de cada execução do loop. Use a função GetTickCount para capturar o tempo.

A cada loop some 16.66 ao tempo de execução do loop anterior, subtraia pelo tempo atual e o resultado será o tempo que o loop deve aguardar (Sleep). Se o resultado for negativo então o loop não deve aguardar.

Código abaixo pode ser mais esclarecedor:

// ...
int iSleepTime = 0;
BOOL bPeekMsgRes;
DWORD lastTime = GetTickCount();
 
while(1) // Main event loop
{
 
    bPeekMsgRes = PeekMessage(&Msg,
                              NULL,
                              0,
                              0,
                              PM_REMOVE);
   if(bPeekMsgRes)
   {
       if(Msg.message == WM_QUIT)
       {
           break; // Break main event loop
       } else {
           TranslateMessage(&Msg);
           DispatchMessage(&Msg);
       }
   }
 
   /* ---- Main game processing ---- */
   // Corta, pica e fatia no jogo...
 
   /* ---- FPS control ---- */
   lastTime += 16.66;
 
   iSleepTime = lastTime - GetTickCount();
 
   if(iSleepTime > -1)
   {
       // Normal
       Sleep(iSleepTime);
   } else {
       // Lento
       printf("OMG! Tá lento isso hein?\n");
   }
}
 
/* ---- Game Over ---- */
// ...

obs: Tem um "printf" ali que só vai aparecer se a janela tiver um prompt. Você pode compilar sua aplicação/jogo/miojo para que seja exibido o prompt junto, não sei como se faz isso no VisualC++, mas no DevC++ (GCC) crie um projeto "Win32 Console" ou compile com "-mconsole".

Os primeiros testes que fiz (com a ajuda do Gean) foi usando a documentação oficial do Python que pode ser encontrada aqui. Foi relativamente fácil e não tive muitos (mais do que nenhum) problemas.

Porém a perfomance não era a esperada, então parti para outros testes, e um desses foi exatamente sobre a biblioteca ctypes. Atualmente ela é um pacote "third-part" (feito por terceiros), porém, será builtin na versão 2.5

Sua instalação é simples e seu uso mais ainda.

Então vamos aos códigos, nós vamos fazer a clássica função fatorial. Pra começar precisamos definir os arquivos:

• teste_fatorial.py Arquivo que vai chamar a função em C
• fatorial.c Código que contém o algorítimo da função

Aqui está a implementação dos arquivos:

fatorial.c
[c]
/*
* Pra compilar esse codigo como biblioteca usando o GCC execute:
* gcc -o fatorial.so -shared fatorial.c
*/
#include

int
fatorial(int numero, int mult)
{
if (numero == 1)
{
return mult;
}
else
{
return fatorial(--numero, mult*numero);
}

}
[/c]

teste_fatorial.py
[python]
import ctypes

# A biblioteca tem que estar no mesmo diretorio do teste_fatorial.py
Fatorial = ctypes.CDLL("./fatorial.so")

# Seta o retorno da funcao para inteiro
Fatorial.fatorial.restype = ctypes.c_int

# Imprime o resultado da funcao
print Fatorial.fatorial(5, 1)
[/python]

Como você pode ver, nenhuma alteração no código em C precisa ser feita, você pode importar qualquer modulo pré-compilado que já exista, como a libc, a libgd e muitas outras já existentes no Linux.

Depois de carregar uma biblioteca, é recomendável que você altere o restype das funções que você vai chamar, por exemplo, no exemplo do fatorial eu setei para c_int, pois isso é o que a função retorna, um inteiro. Essa e outras observações você encontra na documentação do ctypes e na página do Python