Ultimamente tenho ouvido falar muito sobre desenvolvimento orientado a testes (Test Driven Development). Uma grande vantagem dessa forma de produzir código é que você consegue garantir a consistência do seu sistema. Quando possuímos bons casos de teste, caso um bug seja inserido durante o desenvolvimento, identificamos o problema assim que rodarmos os casos de teste. Ou seja, trocamos dezenas de horas de debug por alguns segundos (ou talvez minutos) de testes rodando. Assim você acaba produzindo software em um tempo muito menor e provavelmente a qualidade do seu sistema será melhor também.

Infelizmente não encontrei nenhum framework que facilite este tipo de desenvolvimento em C, mas é simples produzir um script (em bash, perl, ruby, etc) que rode seus casos de teste sempre que você quiser. O grande segredo é deixar tudo automatizado (rodar os testes, checar as respostas e avisar onde um possível erro está ocorrendo), assim você não fica cansado de ficar compilando seus testes manualmente para ver se o sistema funciona.

Algumas dicas para quem pretende desenvolver utilizando testes:

• Escreva seus casos de teste antes de escrever suas funções. Isso força você a pensar melhor em casos que podem quebrar o código que você ainda vai escrever, além de diminuir o número de testes viesados (que contém os mesmos erros que seu código, por exemplo).
• Idealmente, teste todas as suas funções. Na prática isso dificilmente acontece, mas é o ideal.
• Teste como suas funções se integram com as outras.
• Teste como seus módulos se integram com os outros.
• Para cada bug (que inevitavelmente ocorrem), crie um caso de teste para evitar que esse bug seja reinserido em modificações futuras.
• Testes são seus amigos. Não modifique-os apenas para ver todos os testes passando. Só modifique-os quando for realmente necessário.

Mais informações: Wikipedia

Com isso encerro a série Dia C. Espero que tenham gostado.

Posts Relacionados:

Testes unitários em C++

Red, Green, Refactor?

Os criadores do Skype atacam novamente…

Séries

Infinitest

Por tudo que é sagrado, escrevam testes!

TDD para Ruby - Fibonacci

Acompanhe-nos por RSS, por Email ou via Twitter.
Veja como ter um desconto no Dreamhost: um excelente servidor web.

Variáveis

Em C, uma variável pode ser visto de forma semelhante a que é vista em matemática. Ela é um lugar para você colocar valores. A diferença é que é um conceito mais restrito. Cada variável possui um tipo e apenas valores desse tipo podem ser colocados dentro da variável. A variável também possui limitações. Por exemplo, você não pode colocar um número real dentro de uma variável inteira. Se você fizer isso, o compilador poderá gerar um aviso, erro ou fará algum malabarismo para conseguir colocar dentro da variável. No caso, ele pegará apenas a arte inteira do número real.
Além disso, as variáveis possuem um valor máximo e mínimo que pode ser colocado dentro delas. Qualquer valor entre esses dois extremos (inclusive) pode ser atribuído (colocado) a variável. Um valor fora desse limites geralmente irá produzir resultados estranhos, como uma multiplicação entre dois números positivos gerando um número negativo.

Tipos Primitivos

C possui diversos tipos de variável que já vem definidos e que você pode usar para compor outros. Esses são os tipos primitivos.

Aqui vai uma tabela com os principais tipos primitivos e seus valores máximos e mínimos:

Tipo	Equivalente	Valor Máximo	Valor Mínimo	Número de bytes em geral(processador de 32 bits)
char	Armazena o código de um caractere	127	-128	1
int	Armazena um inteiro	2147483647	-2147483648	4
long	Armazena um inteiro	2147483647	-2147483648	4
float	Número real com precisão simples	???	???	4
double	Número real com dupla precisão	???	???	8

Além dos tipos primitivos, existem modificadores para o tamanho desses tipos:

Modificador	Efeito
short	Reduz pela metade o número de bytes do tipo primitivo
long	Dobra o número de bytes do tipo primitivo
unsigned	Define que o tipo apenas representará valores positivos
signed	Define que o tipo representará valores positivos e negativos

Usando Variáveis

Em C, para se utilizar uma variável, é necessário declará-la antes. Para isso, você deve também indicar de qual tipo que ela seja. A sintaxe é basicamente:

tipo nome_da_variavel;

Alguns exemplos:

int i;
long long inteiro_bem_longo;
float pontoFlutuante;
double pontoFlutuante2;
long double CaSeSeNsItIvE;
short int podemosUsarVariosCaracteresNoNomeDaVariavel;

Em C, nomes (de qualquer coisa) podem possuir muitos caracteres (não pude encontrar um valor máximo, mas meus testes mostraram que até 10765 caracteres funciona), desde que não sejam começados por números (podem possuir números a partir do segundo caractere, mesmo que seja entre caracteres) ou operadores. Também não é permitido dar nomes iguais, mesmo que seja para coisas diferentes.

Posts Relacionados:

JSF - Container

YACP - Definindo seus próprios tipos

YACP - Condições Booleanas

Linguagens de programação - Smalltalk

Guia Latex - Parte II: O Básico

YACP - Aprendendo a usar suas ferramentas

SNL - A Arte da Guerra

Acompanhe-nos por RSS, por Email ou via Twitter.
Veja como ter um desconto no Dreamhost: um excelente servidor web.

Agora que você já instalou seu compilador, editor de texto favorito e depurador, nada como algumas dicas de como usá-los.

Usando o GCC

Para compilar um programa, abra um terminal (Linux: [xgk]term, rxvt, etc…; MacOS X: Terminal, DashBoard Shell, etc…; Windows: cygwin). No terminal digite a seguinte linha:

gcc -Wall -pedantic -std=c99 -g seu_arquivo.c -o arquivo_de_saida

Lembre de trocar seu_arquivo.c pelo arquivo que você quer compilar e arquivo_de_saida pelo nome que você quer dar para o seu executável.

A flag Wall serve para que o compilador gere o maior número possível de avisos de coisas que podem estar erradas no seu programa. Std=c99 é para ele compilar usando ISO C 99 como padrão e pedantic é para ele forçar o padrão de compilação (se não usar, ele pode deixar passar algum código que não seja ISO C 99). G é para que ele gere marcações para o depurador, facilitando o processo de depuração mais tarde.

Rodando seu programa

Em Linux, Windows e MacOS X, digite:

./nome_do_seu_programa

Usando o GDB

Para rodar o GDB, digite:

gdb nome_do_seu_programa

O GDB possui diversos comandos internos:

• r - Roda o seu programa dentro do gdb
• b [nome_funcao|linha do programa] - Pausa a execução do programa (breakpoint) quando a função nome_função for chamada ou quando o programa for executar o comando que está na linha indicada
• n - Executa a próxima linha do seu programa
• c - Continua a execução até que um breakpoint seja atingido

Existem vários outros mas esses devem ser os mais usados.

Usando o GVim

O Vim possui vários modos de utilização. Vamos nos focar no modo de comando (padrão) e de inserção. No modo de comando não aparece nada escrito no canto inferior esquerdo da tela (a não ser mensagens de erro em vermelho. Você vai notar.) Neste modo é possível salvar seu arquivo, abrir um novo, fechar o Vim, etc.
Aqui vão alguns dos comandos mais usados:

• :sav nome_arquivo - Salva o arquivo atual em nome_arquivo
• :w - Escreve o arquivo atual
• :q - Fecha o Vim
• :x - Escreve o arquivo e fecha o Vim
• :e nome_arquivo - Abre o arquivo nome_arquivo (cria um novo se não existir arquivo com o nome
• a - Muda para o modo de inserção (não tem ‘:’ antes do ‘a’)
• u (no modo de comando) - desfazer
• :syn on - Ativa o modo de coloração (muito útil quando programando)
• :set ai - Ativa a autoindentação
• :set cindent - Ativa o modo de indentação para C
• :set nu - Coloca numeração nas linhas do seu programa
• :set ruler - Coloca indicador de linha e coluna de inde o cursor está
• :set keymap=accents - Se seu teclado não estiver bem configurado, no Vim ele colocará acentos
• :set noexpandtab (Veja os comentários)

Os últimos 6 comandos podem ser colocados em um arquivo especial chamado .vimrc (_vimrc no Vim para Windows e .vimrc no cygwin). Esse arquivo possui comandos que serão executados sempre que você abrir o Vim/GVim. Assim não é necessário digitá-los toda vez que for programar. Este arquivo costuma se localizar na sua home.

O modo de inserção serve para você modificar o texto do arquivo. Para voltar para o modo de comando aperte Esc.

Usando o Emacs

Já o emacs possui apenas um modo e uso. Inserção. Isso significa que você não precisa fazer nada antes de começar a digitar seu programa. Aqui vão alguns comandos úteis (embora você possa fazer tudo com o menu):

• ctrl-x+ctrl-f - abre um arquivo
• ctrl-x+ctrl-s - salva o arquivo
• ctrl-x+ctrl-c - sai do emacs
• ctrl-espaço - seleciona texto
• alt-w - copia texto selecionado
• ctrl-w - recorta texto selecionado
• ctrl-y - cola o texto previamente copiado
• ctrl-_ - desfazer

Posts Relacionados:

Um pouco de Bash - Parte I

Aplicações portáveis em C/C++

Pesquisa sobre ferramentas para desenvolvimento livre

Google para todos os gostos

Desenvolvimento de jogos com o Morphic

18 dicas para o Google Calendar

YACP (Yet Another C Primer)

Acompanhe-nos por RSS, por Email ou via Twitter.
Veja como ter um desconto no Dreamhost: um excelente servidor web.

Este é o primeiro post de uma série que tem por objetivo ensinar programação em C a alguém que já tem noção do que é programação, mas nunca programou. Programadores menos experientes também encontrarão muito material útil aqui.

Esta série está dividida em três partes:

1. Apresentação e instalação de compiladores, bons editores de texto e um depurador.
2. Estrutura da linguagem de programação C.
3. Bibliotecas do padrão ANSI C (ISO C 89) e ISO C 99.

A primeira parte, irá mostrar rapidamente como instalar o compilador GCC, os editores de texto GVim e Emacs e o depurador GDB.

A segunda parte tratará de como a sintaxe de C é estruturada e das palavras reservadas a linguagem. Introduzirá o conceito de variáveis, a estrutura de controle de fluxo de um programa, operações com os temidos ponteiros (que são bem mais simples de usar do que as pessoas costumam pensar), manipulação de bits, funções e preprocessamento.

A terceira parte vai funcionar como um guia de referência para as funções dos padrões ANSI e ISO C 99. Assim você poderá saber qual suporte C oferece para seus programadores.

Instalando o GCC

O GCC é um dos melhores compiladores da linguagem C que existe. Boa parte do que foi adicionado ao padrão ISO C 99 eram extensões apenas do GCC. Além disso ele é OpenSource. Nos exemplos vou usar o GCC, mas qualquer compilador ISO C 99 deve compilar os exemplos.

Instalar o GCC em Linux é bem simples. Provavelmente você já possui ele instalado (sei apenas de uma versão do Ubuntu que não vinha com o GCC por padrão). Para checar, abra um terminal e digite ‘gcc –version’. Ele irá informar qual a versão do compilador. Se a shell devolver alguma mensagem de erro, instale o GCC com o seu gerenciador de pacotes (como são muitos, não vou entrar em detalhes).

Em MacOS X, você deverá se cadastrar na Apple Developer Connection (ADC) e baixar o pacote xCode. O xCode vai instalar dezenas de programas, bibliotecas e frameworks em seu computador. Possui muita coisa realmente útil e muita coisa inútil. Ainda bem que você pode escolher o que instalar.

Em Windows, a melhor opção é instalar o cygwin, que é um emulador de Linux para Windows. Muito bom.

Instalando o depurador

O depurador que uso é o GDB (GNU Debugger). Excelente depurador, poderá ajudar muito a detectar algum erro em seus programas.
Em Linux ele já deve estar instalado, caso contrário siga o mesmo procedimento feito para o GCC.
Em MacOS X, o xCode já instala o GDB.
Em Windows, o cygwin também já traz o GDB.

Instalando um editor de textos

Em Linux e MacOS X, o vim vem instalado por padrão. Para instalar o Gvim use seu gerenciador de pacotes preferido ou acesse o site do Vim e faça o download.

Para instalar em Windows, acesse o site do Vim e pegue o instalador.

Além do Vim, existe um outro bom editor chamado Emacs, criado por Richard Stallman.

Para instalar o Emacs no Linux basta usar o seu gerenciador de pacotes (Portage, Synaptic, etc…) e escolher a opção de instalar o Emacs. Caso sua distribuição não tenha um gerenciador de pacotes, entre no site do Emacs e faça o download.

Para instalar no Windows, acesse o site do Emacs e pegue o pacote de arquivos pré-compilados. Ele não contém um instalador, mas basta extraí-lo (ele é um .zip) e executar o bin/runemacs.exe, você pode deixar a pasta em qualquer lugar mas é interessante deixar em um lugar fácil de lembrar (C:\ ou Arquivos de Programas).

Posts Relacionados:

YACP - Condições Booleanas

YACP - Variáveis e Tipos Primitivos

YACP - Aprendendo a usar suas ferramentas

YACP - Definindo seus próprios tipos

Acompanhe-nos por RSS, por Email ou via Twitter.
Veja como ter um desconto no Dreamhost: um excelente servidor web.