Vetores – Parte 1 – O que é um vetor?

Já imaginou fazer um programa que processe mil números inteiros? Que ainda necessite calcular a média desses números e apresentar quantos números estão acima dessa média?
Se você pensou em criar mil variáveis então sugiro repensar seus conceitos. :-P
A nossa velha linguagem C possui uma estrutura de dados chamada vetor, a qual agrupa um conjunto de variáveis, fazendo com que elas atendam por um único identificador. O que mantém a individualidade de cada uma dessas variáveis é o índice pelo qual elas respondem. Veja a figura abaixo:

O vetor identificado por vet contém dez elementos, os quais possuem um índice variando de 0 a 9. Cada posição do vetor se comporta de forma independente das demais, como se fosse uma variável isolada.
Se vet fosse um vetor de inteiros, sua declaração seria:

int vet[10];

Generalizando a criação do vetor temos:

tipo_de_dado identificador [capacidade];

Onde:

• tipo_de_dado é qualquer tipo de dado possível para a linguagem C, seja ele básico, estendido ou definido pelo usuário;
• Identificador é um identificador válido para a linguagem C;
• capacidade é uma constante inteira definida pelo programador a qual define o número de elementos de um vetor.

Como o vetor é um tipo de dado estático, sua capacidade é atribuída pelo programador e sua alteração exige uma nova compilação do programa. Essa característica faz com que o vetor fique limitado aquele número de elementos.
Acho que está bom para esse primeiro papo né? Espero que aquela idéia triste de criar mil variáveis deva ter abandonado a sua cabeça. ;-)
A nossa próxima conversa será sobre a inicialização e acesso as posições do vetor. Fique a vontade em divulgar, comentar e sugerir....
Abraços.

Outros operadores de atribuição.

Como assim? Existem mais operadores de atribuição além do =?
A linguagem C fornece mais cinco operadores de atribuição, além do tradicional =.
Vamos ao exemplo. Suponha que uma variável a é incrementada em 3 unidades, portanto, a linha de código que define esse incremento é


a = a + 3;


Essa linha pode ser substituída por


a += 3;

Ambas produzem o mesmo resultado, mas a escrita da segunda é facilitada, pois a utilização do valor da variável está implícita no operador de atribuição. Os programadores C utilizam largamente esses operadores de atribuição, os quais existem um para cada operação aritmética definida.
A tabela abaixo apresenta um resumo das expressões e os operadores aritméticos envolvidos.

Operador	Expressão original	Expressão equivalente
+=	a = a + n;	a += n;
-=	a = a - n;	a -= n;
*=	a = a * n;	a *= n;
/=	a = a / n;	a /= n;
%=	a = a % n;	a %= n;

Espero ter incrementado o vocabulário da linguagem C com esses novos operadores.

Pré ou pós? Quando usar?

No post anterior falei dos operadores de incremento e decremento. Em todos os exemplos, os operadores aplicados foram pós-fixados, ou seja, aparecem logo após a variável. Naqueles exemplos tanto faz a posição do operador porque o resultado obtido é sempre o mesmo.
Quando utilizamos os operadores de incremento e decremento dentro de comandos mais complexos existe a diferença entre o uso pré-fixado ou pós-fixado. Vejamos o código abaixo para o operador pós-fixado:

int a = 5, b;

b = a++;


Qual o valor das variáveis a e b?
O valor esperado para a é 6 e para b é 5.

Se utilizarmos o operador pré-fixado, conforme exemplo abaixo:

int a = 5, b;

b = ++a;


O valor esperado para ambas as variáveis é 6.
Notaram a diferença?
Quando o operador é pós-fixado, o valor da variável é utilizado no comando e após a conclusão desse comando o valor será atualizado. No primeiro exemplo, o comando é de atribuição, seguido da atualização da variável pelo operador de incremento, uma vez que ele é pós-fixado. Com isso o valor de a, que é cinco, é atribuído à variável b e então a variável a é atualizada.
Quando o operador é pré-fixado, primeiro a variável é atualizada para então utilizar o seu valor. No segundo exemplo percebemos que a variável a é atualizada para seis e então o comando de atribuição é executado, passando para a variável b o valor 6.
Esse comportamento é análogo para os operadores de decremento, só que diminuindo o valor em uma unidade ;)
Em linhas gerais:
Operador pré-fixado, atualiza (incrementa ou decrementa) e depois usa o valor.
Operador pós-fixado, usa o valor e depois atualiza (incrementa ou decrementa).
Espero que isso ajude vocês a compreender melhor esses operadores.

Operadores de incremento e decremento

Operadores de incremento e decremento

A linguagem C é cheia de atalhos para o programador.
Um dos atalhos mais utilizados é o operador de incremento (++). Esse operador é largamente utilizado no for.
Esse operador incrementa a variável em uma unidade.
Um exemplo prático pode ser visto logo abaixo:

int a;
a = 7;
a++;
printf("%d\n", a);

A saída produzida por esse programa é 8. Como esperado, o operador de incremento funciona como

a = a + 1;

incrementando a variável a.
Análogamente ao operador de incremento a linguagem C disponibiliza o operador de decremento --.
Aplicando o operador de decremento ao código de exemplo temos:

int a;
a = 7;
a--;
printf("%d\n", a);

Como é de se esperar a saída apresentada foi 6.
Esses operadores utilizados isoladamente não são complexos, mas quando utilizado dentro de expressões aritméticas tornam o código complexo.
Brevemente falaremos do uso dos operadores de incremento e decremento pré-fixado ou pós-fixado.

Do while

Do while

O do while é um laço de repetição que executa primeiro o bloco de comandos e depois testa a condição. Caso a condição seja verdadeira, o laço é executado novamente. Quando a condição é falsa, a execução do laço é terminada.
Essa característica de executar e depois testar, garante que o laço será executado ao menos uma vez, diferentemente do while, o qual não executa quando sua condição é falsa.
A validação de entrada é um exemplo pertinente para o uso do do while, uma vez que a leitura do dado deverá ser executada ao menos uma vez. Quando o dado não é consistente com o conjunto de dados esperados, uma nova leitura é solicitada.
Veja o exemplo abaixo:



001:  #include <stdio.h>
002:  #include <stdlib.h>
003:
004:  int main(int argc, char * argv[])
005:  {
006:    char sexo;
007:
008:    do
009:    {
010:      printf("Digite o sexo: ");
011:      fflush(stdin); scanf("%c", &sexo);
012:      if(sexo != 'M' && sexo != 'F')
013:      {
014:        printf("Digite M ou F\n");
015:      }
016:    }while(sexo != 'M' && sexo != 'F');
017:    system("PAUSE");
018:    return 0;
019:  }



Note que o código é feito para importunar o usuário de forma que ele digite M para masculino ou F para feminino. Em outras palavras, o programa ficará em loop até que M ou F seja digitado. Baseado nisso, posso afirmar que a condição de saída do laço é M ou F.
Com este post finalizei a trilogia de laços de repetição, o que não quer dizer que esgotei o assunto...

While

Retomando o assunto Laços de Repetição, abordado em abril/2008, hoje vamos tratar do while.
A forma geral desse laço é:

while


while(condicao)
{
  comandos...
}


É importante saber que dentro do bloco de comandos do while é necessário tornar a condicao falsa. Caso isso não ocorra, o while entrará em loop infinito.

Vamos recorrer a um exemplo simples:
Suponha que uma cidade A possua 1.500.000 habitantes e taxa de crescimento anual de 1%. Suponha também que uma cidade B com 500.000 habitantes cresce anualmente a 3%. Você deseja saber em quantos anos, mantendo-se as taxas de crescimento, a população de B será maior que a população de A.


001:  #include <stdio.h>
002:  #include <stdlib.h>
003:
004:  int main(int argc, char * argv[])
005:  {
006:    int anos=0;
007:    float popA=1.5, popB = 0.5;
008:
009:    while(popA >= popB)
010:    {
011:      popA = 1.01 * popA;
012:      popB = 1.03 * popB;
013:      anos += 1;
014:    }
015:    printf(“Quantidade de anos necessaria: %d\n”, anos);
016:    system("PAUSE");
017:    return 0;
018:  }


O exemplo mostra que enquanto a condição for verdadeira, ou seja, a população de A for maior ou igual a B, os anos passam (linha 13), e a população cresce (linhas 11 e 12).
Os dados de população e taxa de crescimento possibilitam que em algum ano, a população da cidade B será maior que a de A.
Caso a taxa de crescimento de A fosse maior que a de B, nunca a condição de saída seria atingida.
Sempre que trabalhar com o while, verifique a condição e identifique quais linhas tornarão seu resultado falso e se isso acontecerá. Com essa verificação seu laço não entrará em loop infinito.
Agora farei algumas considerações com relação aos cálculos praticados nas linhas 11 e 12, os quais podem parecer obscuros a alguém.
A linha 11 poderia ser reescrita como:


popA = popA + 1.0/100 * popA;



Dividindo 1.0/100 temos:



popA = popA + 0.01 * popA;



Colocando popA em evidência temos:



popA = (1 + 0.01) * popA;



Efetuando a soma 1 + 0.01 fica:



popA = 1.01 * popA;



Bendita ou maldita matemática. :D

For

No tópico Laços de Repetição foram abordados de forma geral os três laços possíveis na linguagem C.
Esse tópico trata do laço for.
Como visto, a forma geral desse laço é:

for


for(variavel = valor_inicial; condicao_envolvendo_variavel; incremento/decremento de variavel)
{
  comandos...
}


Vamos vê-lo na prática:


001:  #include <stdio.h>
002:  #include <stdlib.h>
003:
004:  int main(int argc, char * argv[])
005:  {
006:    int i;
007:
008:    for(i = 0; i < 10; i++)
009:    {
010:      printf("%d\n", i);
011:    }
012:    system("PAUSE");
013:    return 0;
014:  }


O exemplo, embora simples, ilustra que o início do for é bem definido, bem como seu fim. Note que a variável i inicia com 0 e termina com 10.
Quando estou em sala de aula sempre pergunto quantas vezes o for será executado. A resposta é 10 vezes, com i variando de 0 a 9 (i < 10).
Se não confia em mim, execute o código acima e verifique as impressões do valor de i. Deverá aparecer 0, 1, ..., 9.
Outra pergunta que costumo fazer é qual o valor de i após a execução do laço for, em outras palavras, se imprimisse o valor de i na linha 012, o que seria impresso? A resposta correta é 10, lembre-se que existe uma condição para o for ser abandonado (i < 10). Quando i valer 10, o laço termina a sua execução.
Agora vamos ao exemplo prático. Vamos calcular o fatorial de um número inteiro.


001:  #include <stdio.h>
002:  #include <stdlib.h>
003:
004:  int main(int argc, char *argv[])
005:  {
006:    int fat = 1, n, i;
007:
008:    printf("Digite o numero: ");
009:    fflush(stdin); scanf("%d", &n);
010:
011:    if (n < 0)
012:    {
013:      printf("Nao existe fatorial de numero negativo.\n");
014:    }
015:    else
016:    {
017:        for(i = n; i > 1; i--)
018:        {
019:            fat *= i;
020:        }
021:        printf("%d! = %d\n", n, fat);
022:    }
023:    system("PAUSE");
024:    return 0;
025:  }


Verifique o início e o fim do laço, novamente bem definidos! Inicia em n e termina em 1.
A linguagem C permite que você altere, dentro do laço, os valores da variável de controle (i). Essa não é uma prática recomendável porque esse laço perde sua característica de executar um número determinado de vezes. Se você alterar os valores da variável de controle, não poderá garantir quantas vezes o laço será executado.