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.

O Terminal é uma das ferramentas mais interessantes do Linux, e mesmo que você tenha o X instalado, dominar o bash é muito útil para realizar tarefas de forma muito mais rápida. Programadores normalmente usam mais o terminal do que a interface gráfica, sendo que já presenciei um amigo usar o lynx por ser mais rápido do que abrir o firefox e entrar numa determinada página na qual ele não precisava visualizar imagens.

Quem usa muito o terminal normalmente acaba usando alguns alias para melhorar ainda mais o tempo de realizar tarefas. Alias são atalhos criados no terminal que permite renomear comandos, mas que são exclusivos para o terminal e a sessão atual, para que os mesmos se tornem permanentes é necessário “carrega-los” sempre que um terminal for aberto e isso é feito modificando o ~/.bashrc (existe um bashrc geral para o sistema no /etc/bash.bashrc no Ubuntu e no /etc/bash/bashrc no Gentoo).

Vamos primeiro salvar um backup do bashrc atual por segurança. Para isso digite:

cp ~/.bashrc ~/.bashrc.bak

Caso algo saia errado durante esse tutorial basta reescrever o bashrc antigo com:

cp ~/.bashrc.bak ~/.bashrc
Para evitar ficar escrevendo diretamente no bashrc, que pode precisar ser atualizado pela distribuição, é melhor criar um arquivo a parte e referencia-lo no bashrc. Isso pode ser feito dessa forma:

if [ -f ~/.bashrc ]; then
source ~/.VidaGeek_bashrc
fi

O objetivo é criar atalhos para os comandos mais utilizados no terminal e podemos descobrir quais são esses comandos através deste comando:

history | awk '{print $2}' | awk 'BEGIN {FS="|"}{print $1}' | sort | uniq -c | sort -n | tail | sort -nr

Para quem instala muita coisa no sistema provavelmente o comando mais utilizado seja o sudo pois ele é utilizados na administração do sistema (isso pode não ocorrer se você executa seus comandos como root). Podemos encurtar estes comandos que normalmente utilizam o sudo e ainda por cima precisam de vários parâmetros. Para criar estes atalhos adicione as linhas abaixo no arquivo ~/.VidaGeek_bashrc. Os próximos comandos estão em duas versões, uma para Ubuntu e outra para Gentoo, mas podem ser alterados para refletir o gerenciador de pacotes da sua distribuição.

Instalação
Ubuntu: alias inst="sudo apt-get install -y"
Gentoo: alias inst="sudo emerge"

Desinstalação
Ubuntu: alias remp="sudo apt-get remove"
Gentoo: alias remp="emerge -C"

Busca de pacotes
Ubuntu: alias search="apt-cache search"
Gentoo: alias search="emerge -s"

Atalhos para todas distribuições
Estes atalhos são para qualquer distribuição Linux podendo ser usados normalmente (apenas um detalhe: você precisa do gcc e g++ instalados caso use os atalhos de programação)

Movimentação entre pastas
Mudando o ls para um arquivo por linha e arquivos ocultos: alias ls="ls -al"
clear com uma tecla: alias c="clear"
up para pasta anterios: alias up="cd .."
home para voltar na pasta home: alias home="cd ~"
disk para ir a raiz do sistema: alias disk="cd /"
trash para limpar a lixeira: alias trash="rm -fr ~/.Trash"

Comando seguros
Mudando o rm: alias rm="rm -i"
Mudando o mv: alias mv="mv -i"

Comandos para programadores
Compilando com ANSI-C: alias ansi-gcc="gcc -Wall -ansi -pedantic"
Compilando com ANSI-C++: alias ansi-gcc="g++ -Wall -ansi -pedantic"

Mudando o histórico
O histórico é muito útil para os viciados em terminal, pois com apenas algumas teclas nos poupamos o trabalho de reescrever uma linha inteira e possivelmente longa. Além das setas para cima e para baixo, podemos usar também o ctrl+r para buscar comandos digitados. Para aumentar o tamanho do seu histórico coloque as seguintes linhas no seu arquivo:
HISTFILESIZE=100000000
HISTSIZE=100000
Mas algumas pessoas preferem que não haja histórico por uma questão de privacidade, caso você prefira desse jeito coloque:
HISTFILESIZE=0
HISTSIZE=0

Completion
O completion (acessado pelo tab) é outra coisa muito interessante do terminal e normalmente as distribuições oferecem ainda
pacotes com mais opções de completion (como o Gentoo através do gentoo-bashcomp). Mas algumas vezes o completion, mesmo instalado, precisa ser iniciado pelo bashrc, isso deve ser feito adicionando este código (não há problema em adiciona-lo se já estiver ativo):
if [ -f /etc/bash_completion ]; then
. /etc/bash_completion
fi
No caso do Gentoo, se você instalou o gentoo-bashcomp adicione também:
[[ -f /etc/profile.d/bash-completion ]] && \
source /etc/profile.d/bash-completion


Encriptando e Desencriptando
É possivel encriptar e desencriptar um arquivo facilmente através dos comandos encrypt e decrypt seguido do arquivo adicionando estes comandos e garantindo que você tem o gpg instalado.
encrypt ()
{
gpg -ac --no-options "$1"
}
decrypt ()
{
gpg --no-options "$1"
}

Mensagem Inicial
Você pode alterar a mensagem que aparece quando você abre o terminal. Para isso você pode usar comandos como o echo que imprime no terminal uma frase entre aspas. Uma outra coisa interessante é mostrar o fortune, um programa que mostra frases variadas, sempre que inicia o terminal. Abaixo há um exemplo com alguns comandos úteis.

clear
echo -ne "Hoje e "; date
echo -e ""; cal ;
fortune

Mensagem customizada de prompt
Por fim, podemos alterar o costumeiro rafael@PowerTux ~ $ por algo mais simpático, como [19:28:05 rafael ~]$, para isso adicione:

PS1="[\t \u \W]\\$ “

Arquivos deste tutorial
Disponibilizei três versões do arquivo deste tutorial, uma para Gentoo, uma para Ubuntu e uma para qualquer distribuição (pois não contém os comandos de instalação). Você precisará renomea-las para .VidaGeek_bashrc e colocar na sua home para poder usar.

Espero que este tutorial tenha sido útil para aprender um pouco mais sobre bash e para melhorar o seu desempenho no terminal.

Adaptado do LifeHacker

Posts Relacionados:

Aprendendo Bash

Aprenda Comandos Básicos de Linux

Como exibir branch atual do git

Gnome Do

YACP - Aprendendo a usar suas ferramentas

Wicd: Um gerenciador de redes alternativo

Um dia de usuário

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

O Ubuntu é uma distribuição do tipo instale-esqueça, em que usuário iniciantes em Linux podem ter um sistema open-source fácil de usar e capaz de realizar as mesmas coisas que já estão acostumados com sistemas proprietários. Mas existe alguns truques que podem ser feitos para melhorar a eficiência geral do sistema e que por motivos de compatibilidades não estão ativos após a instalação. Segue três itens interessantes sobre este aspecto:

Controle do SWAP

O Swap é feito toda vez que o sistema acredita que deva guardar no disco parte das informações da RAM para não ocupá-la inteiramente. Existe um forma de definir quão frequentemente o kernel deve realizar o swap, apesar de o assunto ser discutível.

Você pode descobrir o seu “swappiness” através do comando
sudo cat /proc/sys/vm/swappiness

Seu sistema deve ficar mais rápido se você diminuir este valor, através do comando
sudo sysctl -w vm.swappiness=10

Mas esta alteração não é permanente, para alterar permanentemente este parâmetro altere o arquivo /etc/sysctl.conf na opção vm.swappiness e mude para 10 (crie se não existir).

Removendo Terminais

Se você não usa muito os terminais do seu Ubuntu, você pode diminuir o numero dos mesmos para economizar memória. Para isso edite o arquivo /etc/inittab, procurando pela linha
2345:respawn:/sbin/getty 38400 tty1
Ela e as seguintes indicam cada um dos tty’s e você pode comentá-las com um # na frente da linha. Recomendo não remover o tty1 pois ele pode ser útil se algo de estranho ocorrer com o seu X.

Boot Concorrente

Como o Ubuntu foi criado para um sistema genérico ele não utiliza os outros (possivelmente existentes) processadores da máquina durante o processo de inicialização. Editando o arquivo /etc/init.d/rc trocando CONCURRENCY=none para CONCURRENCY=shell você muda o seu boot de normal para paralelo. Para ver se isto foi útil você pode usar o Bootchart.

Posts Relacionados:

Livro grátis de Ubuntu

Ubuntu planeja versão móvel

Compartilhando pastas e arquivos com Ubuntu

Ubuntu como Ferramenta de Recuperação

Ubuntu Ganha o Parlamento Francês

Meu Ubuntu fala!

Firefox 3.5 e Gears no Ubuntu

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.