Quaddro + MacMagazine: programando em C — variáveis

Declaração de uma variável

Continuando nossa série, depois dos primeiros passos e do primeiro projeto em C, vamos agora avançar e mexer com três dos mais importantes recursos que existem para qualquer linguagem de programação: variáveis, condicionais e repetidores.

Não importa o grau de complexidade que um sistema tenha, assim como não importa a linguagem utilizada; o uso desses três elementos é quase obrigatório. Por isso vamos estudá-los um de cada vez e sempre na dupla conceito+prática. Este primeiro texto será sobre variáveis.

Pré-requisitos

Pré-requisto pessoal: sem música não dá, né?! 😛

Disc Wars, de “TRON: Legacy” ♪

Conceitos

Vou começar este texto falando de variáveis, até porque trata-se de um conceito que vai deixar muito mais fácil a compreensão tanto de condicionais quanto de repetidores.

É inevitável começar com a pergunta: o que é uma variável? E, em sala de aula, ouço as mais diversas respostas. A mais comum: “Variável é algo que varia!” Sem brincadeira, não sei quantas vezes ouvi esse tipo de resposta (acho que mais para descontrair a aula do que efetivamente para responder… rs).

Aos iniciantes, uma dica nessas horas de definições e conceitos básicos é evitar explicações extensas e super-elaboradas. Você fixa o que é fácil e direto, e não o extenso e elaborado. 😉

Conceitualmente, uma variável é um espaço em memória que pode armazenar valores. Imaginem uma variável como uma “caixa”, que pode guardar coisas para você usar depois. Assim como existem objetos de tamanhos diferentes, existem caixas com tamanhos diferentes. E isso nos leva a falar de tipagem.

O tipo de uma variável está diretamente relacionado com o que vai ser guardado na “caixa”, assim como o seu tamanho. Para esse nosso estudo inicial, vou destacar dois tipos de dados: int e float.

Uma variável do tipo int pode armazenar números inteiros. Já uma variável do tipo float pode armazenar números de ponto flutuante, ou seja, o popular número “quebrado” com casas decimais.

Isso já nos permite brincar um pouco com código.

Prática

Para que essas fichas caiam, vocês precisam colocar esses conceitos em prática. Para isso, vamos criar um novo projeto. Usaremos o mesmo tipo de projeto do artigo passado: OS X » Application » Command Line Tool, lembrando que na tela onde definimos o nome estamos usando o Type de linguagem como C. Eu vou salvar o meu projeto como Variaveis.

Acessando o arquivo main.c, eu vou apagar o printf padrão com o “HelloWorld”.

Dica: se quiser ganhar espaço para a digitação do código, lembre-se que no artigo passado vimos que na opção View, podemos ocultar o painel Utilities da direta do Xcode.

Eu vou criar primeiramente uma variável numérica. Com base no que vimos até agora, vocês sabem que ela pode ser int ou float, então é inevitável a pergunta de qual usar.

A escolha do tipo de uma variável está relacionada com o que ela armazenará. Nesse caso quero uma variável para guardar o valor de idade de uma pessoa. Concordam comigo que não existe idade com número “quebrado” ou casas decimais?! Com excessão, é claro, dos 23,9 anos ou das mulheres com 30.alguns.

Essa análise nos leva a escolher o tipo int. Definido o tipo e o nome da variável, nós já temos como fazer sua declaração. A tela a seguir ilustra a declaração e o comentário desse processo:

Declaração de uma variável

Antes de falar do código em si, quero chamar a atenção para o tipo de comentário que eu usei. Quando usamos // (barra barra), definimos um comentário de uma única linha. Já se a necessidade é de comentar várias linhas, podemos usar /* abrindo e */ fechando o bloco de comentário.

Ao olhar a declaração da variável, percebemos duas coisas de imediato:

  1. O Xcode usa uma cor específica para os tipos de dados. No estilo padrão é esse tom de rosa. Essa constatação já nos leva a notar outros tipos de dados na tela, como o int da função main e dos seus argumentos. Códigos coloridos são muito práticos porque visualmente você sabe o que é o que (e consequentemente quando algo talvez esteja errado).
  2. Assim que a variável foi declarada, o Xcode passa a exibir uma placa de alerta em sua linha e uma pequena seta embaixo do seu nome.

Aí você pensa: “Poxa! Mal comecei e o código já tem erro?” Calma, gafanhoto, isso não é um erro — é um alerta. Como o próprio nome diz, um alerta está mais para um aviso do que para um erro efetivo. Normalmente (eu disse “normalmente”) o seu programa roda mesmo com o alerta. Isso não quer dizer que você não precisa dar atenção a ele, muito pelo contrário.

A primeira coisa a se fazer quando um alerta aparecer é clicar nessa placa amarela. Isso vai mostrar a descrição do alerta. No nosso caso é uma dica simples: “Variável idade não utilizada.” O que o Xcode está nos dizendo é que você reservou memória para a sua variável, mas ainda não a está usando em nenhum outro lugar do programa. De certa forma, isso é um desperdício dessa memória.

Acostumem-se com esse alerta, pois ele será exibido em TODA declaração de variável, pelo menos até você utilizar essa variável para alguma coisa. No nosso código eu vou adicionar um printf exibindo essa variável.

printf de idade

Percebam que, como nós usamos a variável para alguma expressão, o antigo alerta de utilização some.

Uma observação importante aqui é falar do especificador de formato %. Em algumas funções, para que possamos “incorporar” valores de variáveis, nós precisamos especificar o tipo de dado usado. Como nossa variável é do tipo int, usamos %i. Esse conceito é explicado com calma em um artigo que listei nos pré-requisitos do começo deste texto.

Uma vez que nós tenhamos visto o alerta que o Xcode exibe, é importante aproveitar o momento e conhecer como os temidos erros ocorrem. Uma coisa muito prática do Xcode é fazer uma detecção de erros de sintaxe em tempo real. Isso quer dizer que, se nós fizermos uma bobagem muito grande na sintaxe, teremos noção disso na mesma hora.

Faça um teste: apague o ponto e vírgula do final da linha do seu printf. Assim que o Xcode perceber o que você fez, ele exibirá um erro e não mais um alerta. A identificação visual é uma placa vermelha (no melhor estilo “PARE”).

Se você clicar na placa, será exibida a descrição indicando que o ponto e vírgula era esperado após a expressão. Tenha em mente que, em linhas gerais, todo comando em C deve ser terminado com o ponto e vírgula (isso será mantido em Objective-C).

Erro no Xcode

Outro ponto importante sobre um erro de código é que ele não permite a compilação do seu projeto. A ideia é simples: se há um erro, corrija-o! Isso de certa forma quer dizer que, se você mandar o Xcode compilar e o processo rodar, ótimo. Seu código não tem erros, pelo menos não de sintaxe (erros de lógica são outros 500).

Feita a abordagem sobre erros, vamos voltar nosso código à normalidade. Insiram novamente o ponto e vírgula no final da sua expressão e confirmem se a compilação volta a acontecer.

Voltando a falar de variáveis, vocês devem se lembrar que eu citei dois tipos de dado, mas por enquanto nosso código utiliza apenas um. Vamos dar um jeito nisso já!

Abaixo do atual printf eu vou declarar outra variável numérica, só que dessa vez quero armazenar um valor de altura. Fazendo a análise do que será armazenado, o tipo int não é o mais indicado, uma vez que nós precisamos de casas decimais. Sendo assim, utilizaremos float.

Declaração de uma variável float

O tipo de dado float me permite a atribuição de um valor de ponto flutuante. Percebam que a altura definida foi de 1,55, portanto isso não poderia ser armazenado em um int.

Nesse momento alguns alunos perguntam o porquê de usarmos tipos diferentes, por que não usar apenas um tipo de dado. A resposta é simples: utilização de memória.

Lembram que no começo dessa explicação eu comentei que uma variável pode ser associada a uma caixa?! Também comentei que existem objetos de tamanhos diferentes e consequentemente existem caixas com tamanhos diferentes. Cada tipo de dado usa uma determinada quantidade de memória e quanto melhor forem as suas escolhas de acordo com o uso, melhor será a utilização de memória do seu programa.

E aqui cabe um parênteses: gerenciamento de memória era uma das coisas mais chatas e que mais geravam erros no começo do desenvolvimento para iOS (até a chegada do messias ARC). E digo isso como alguém que fuça e estuda Objective-C desde o primeiro SDK, em longínquos 2008 [alguém aí é da época em que a única referência de estudo era o Learning Objective-C: A Primer?].

Saber utilizar memória é fundamental. Você não pode se dar ao luxo de sair criando variáveis de qualquer jeito, sem se preocupar com a quantidade de uso de memória que isso vai gerar. Então saiba o que você está criando para que, além de definir a menor quantidade possível de memória, na hora certa ela possa ser liberada.

Tradicionalmente, uma variável int ocupa 4 bytes, já uma variável long por exemplo ocupa 8 bytes. Só para comparar, o Apple I tinha 256 bytes de memória ROM. Faças as contas! Mas eu não vou ficar pegando no pé de vocês quanto a gerenciamento de memória (pelo menos não agora… rs). Dado o aviso, vamos prosseguir.

Depois de declarar nossa variável, vamos definir um printf para ela. Assim como definimos um %i para “imprimir” um int, usamos um %f para exibir um float. O código final deve ter ficado assim:

printf de uma variável float

Ao testá-lo, você deve perceber duas coisas interessantes:

  1. Está tudo junto em uma única linha, mesmo que nós tenhamos usado dois printf diferentes.
  2. O valor float foi exibido com diversas casas após o ponto.

A primeira questão é resolvida com o caractere de escape \n (tema abordado nos pré-requisitos do começo do texto). A segunda também é facilmente corrijida com a delimitação da quantidade de caracteres que desejamos exibir. Ao usar %.2f, eu configuro que quero apenas duas casas após o ponto. Fazendo esses ajustes o código resultante, assim como a mensagem, devem ficar assim:

Barra de porcentagem no código

Tenham sempre em mente essa questão do \n para forçar a quebra de linha. Disparado esse é o ponto que os alunos mais esquecem no começo.

Uma vez que nós tenhamos visto a declaração e a exibição de valores de variáveis, podemos brincar um pouco com a alteração de seus valores. Partindo do princípio que uma variável é uma “caixa” para guardar valores, eu posso trocar o que tem dentro da caixa a hora que eu quiser.

Por exemplo, o código a seguir faz uma série de alterações no valor da variável idade. Percebam que deixei o printf após essas operações, assim fica clara a ordem de processamento do nosso código.

Alterando valores de variáveis

Nós declaramos uma variável com tipo, nome e valor (isso se quisermos definir valor logo de cara), mas eu posso alterar o valor armazenado usando apenas seu nome. O processo de leitura do nosso código é feito por um recurso chamado compilador. Ele lê o seu código linha a linha, e por isso o que importa no final das contas para o printf é o último valor que eu mudei.

Toda vez que nós alteramos o valor de uma variável o sistema descarta o valor antigo, então o que importa é o último atribuído.

Outro conceito bacana para o momento é o uso de operadores matemáticos e suas precedências. No código a seguir, eu faço algumas manipulações na altura:

Operações matemáticas no código

Percebam que, além de criar equações simples com os operadores, em algumas situações eu preciso de parênteses para garantir a ordem de resolução. Assim como na matemática, somas e subtrações são processadas depois de divisões e multiplicações. Faça um teste executando o mesmo código sem os parênteses, separando a equação.

·   ·   ·

Eu tinha me programado para falar de condicionais neste texto, mas acho que me empolguei nas explicações e ele já está com um tamanho razoável, então deixo esse artigo para o estudo focado nas variáveis. Na sequência (na semana que vem), subo um degrau utilizando-as em comparações.

Este estudo básico de variável já permite que vocês façam testes mais elaborados, como por exemplo criar uma série de variáveis e exibi-las tanto com vários printf quanto com um único. É um bom exercício de especificadores de formato (%i e %f) e de caracteres de escape (\n e \t).

Até a próxima! 😉

Posts relacionados