sexta-feira, 15 de janeiro de 2010

Pequenas correções na rota

Como falei no último post da série sobre matrizes, hoje falaremos sobre algumas correções necessárias em nossos códigos.

Trabalhando com uma entrada limpa.
No post citado acima inclui um comando novo, e não expliquei o que ele fazia. Antes de ver o que ele faz, vamos ver um código simples que mostra porque ele é necessário.


#include <stdio.h>
#include <stdlib.h>
 
int main (){
 char ch;
 int i;
 
 for(i = 0; i < 10; i++){
    printf("Digite o %do caracter: ", i+1);
    scanf("%c", &ch);
 }
 getchar();
 return EXIT_SUCCESS;
}


Execute esse código e veja o que acontece.
Você conseguiu digitar os 10 valores?
Não??? Por que será?

O buffer do teclado
Quando você pressiona uma tecla (ou conjunto de teclas) em seu teclado é gerada uma informação: a tecla (ou conjunto de teclas) que foi digitada. Esta informação é armazenada em uma área da memória chamada de buffer do teclado, onde fica disponível para ser utilizada. Este buffer pode armazenar uma quantidade razoável de teclas digitadas que serão usadas assim que forem requisitadas.
No código acima, a função scanf 'recupera' o conteúdo de uma dessas teclas, e o armazena na variável ch.
Mas pararmos para pensar, veremos que para armazenar a letra a, por exemplo, na variável ch usando a função scanf, digitamos duas teclas: a tecla a e a tecla enter.
Quando a scanf 'recupera' a tecla a, a tecla enter continua no buffer. Por isso que na próxima chamada da scanf ela irá recuperar o valor da tecla enter, pulando uma entrada. Este problema é clássico e recebeu um nome: sujeira no buffer de entrada.
Existem algumas formas de resolver este problemas.
Vejamos quais são elas, da mais simples à mais drástica (rsrs).

Lendo 2 e ignorando 1.
Este subtítulo diz tudo. Observe o comando abaixo:

 scanf("%c*c", &ch);

Ele faz exatamente isto: Lê 2 caracteres, e ignora o segundo. Susbstituia a chamada da função scanf no código acima e veja a diferença.

Uma outra forma de obter este mesmo resultado é com o seguinte comando:

 scanf(" %c",&ch);

Observe o espaço entre a " e o %. Pode testar. Tem o mesmo efeito.
E se o usuário cometer o erro de digitar mais de 2 caracter antes do enter? Faça o teste.

Pequenas falhas na entrada
A técnica usada acima é pouco eficiente, como podemos ver com este último teste.
Para resolver pequenas erros como este, podemos limpar o buffer usando a função setbuf.
A função setbuf preenche um buffer informado com um valor também informado. Vamos usar o exemplo do código do post sobre matrizes:

 setbuf(stdin, NULL);

O comando acima preenche o buffer da entrada padrão (stdin) com o valor NULL.
A entrada padrão, no nosso caso, é o buffer do teclado. E a palavra NULL é uma constante padrão do C, e significa um valor nulo (um byte com todos os bits 0). Um buffer preenchido com NULL é considerado limpo/vazio.
Para pequenas falhas como uma ou duas teclas a mais esta técnica funciona bem.
É só colocar este comando na linha seguinte a função scanf original que lê apenas um caracter, desta forma:

 scanf("%c", &ch);
 setbuf(stdin, NULL);

Grandes falhas na entrada
O buffer do teclado possui uma característica interessante. Às vezes ele armazena mais do que realmente 'mostra'. Experimente usar este novo código e digitar uns 15 caracteres ou mais, por exemplo, em cada entrada.
A função setbuf limpa somente o que ela 'vê' armazenado no buffer, e logo depois desta limpeza, o buffer é novamente preenchido com o que estava 'oculto' e, desta forma, continua 'sujo'.
Para resolver isto só com 'força bruta' (é só modo de dizer, diga não à violência ;).
Dentre as muitas formas de limpar a entrada usando 'força bruta', eu, particularmente, gosto desta:

 while(getchar()!= '\n');

O comando acima lê os caracteres deixados no buffer, um a um, até encontrar um enter, e despreza todos eles, inclusive o enter.
Substitua o comando setbuf por este mostrado acima e faça o teste. Pode usar 'força bruta' na hora de testar rsrs.


Dando satisfações ao sistema operacional
Existe um outro detalhe no código que usei como exemplo neste post. É o retorno da função main.
Até o momento nós temos usado o retorno das funções para retornar valores para variáveis ou indicar se a função foi bem sucedida. Para isto tenho usado 0 para indicar falha e 1 para indicar sucesso.
A função main também possui um retorno. Em alguns códigos antigos você vai encontrar a main declarada sem retorno ou com um retorno do tipo void. Mas a um bom tempo ela é declarada por padrão com um retorno do tipo inteiro.
Este retorno indica para o sistema operacional se o programa foi concluído com ou sem falhas, ou seja, 0 indica que não houveram falhas, e qualquer número diferente de 0 indica alguma falha.
Você pode usar as constantes padrões EXIT_SUCCESS, que significa que não houve falhas, ou EXIT_FAILURE, que indica alguma falha, ou usar os números diretamente. É muito comum se deparar com um return 0.

System ou não system?
Muitas pessoas criticam o uso da função system (system("pause"); system("cls");).
Um problema que vejo no uso da função system é que ela deixa o código dependente do sistema operacional.
Um system("cls") funciona muito bem para 'limpar a tela' num ambiente Windows, mas não vai funcionar no Linux, onde seria necessário usar um system("clear"). Existem formas de evitar isto usando bibliotecas externas, que funcionam nos dois ambientes. Como o nosso objetivo aqui é aprender o C padrão, vou continuar usando esta função para 'limpar a tela'. Se você trabalha num ambiente Linux, faça a correção quando necessário.
Quanto ao system("pause");, é muito mais simples de resolver. Basta usar um getchar();. Esta função provocará uma pausa na execução do código até que um enter seja digitado, e funciona nos dois ambientes. Não será exibido "Digite qualquer tecla para continuar...", mas o resultado da execução do programa poderá ser visto normalmente. Procurarei usá-la daqui pra frente.

Até o próximo post.

terça-feira, 12 de janeiro de 2010

Matrizes. Final (Matriz de strings/alocação)

Hoje, para encerrar a nossa série sobre matrizes, vamos ver a matriz de strings.

Matriz de Strings
Uma matriz de string é uma matriz de caracteres de duas dimensões, onde a 1a dimensão é a quantidade de strings e a 2a dimensão é o tamanho máximo de cada string.

 char matrstr[5][30];

Na linha acima, definimos uma matriz capaz de armazenar 5 strings que tenham no máximo 29 caracteres cada (o último caracter é o \0, o finalizador da string).
Se quisermos nos referir a cada string individualmente, é só nos referir a uma única dimensão.

 printf("%s\n", matrstr[2]);

O comando acima exibe a 3a string da matriz.

Vejamos um código para exemplificar isto.


#include <stdio.h>
#include <stdlib.h>
const int QTDSTR = 5;
const int COMPRIMENTO = 30;
 
void preenche_matrstr(char matriz[][30]);
 
int main (){
 char matrstr [5][30];
 int i, opcao;
 
 preenche_matrstr(matrstr);
 do{
    printf("Escolha uma das opcao abaixo:\n\n");
    printf("1. Exibir posicoes pares\n");
    printf("2. Exibir posicoes impares\n");
    printf("3. Sair\n\nopcao: ");
    scanf("%d", &opcao);
    switch(opcao){
       case 1:
          for(i = 0; i < QTDSTR; i++)
             if(!((i+1)%2))
                printf("palavra %d: %s\n", i+1, matrstr[i]);
          break;
       case 2:
          for(i = 0; i < QTDSTR; i++)
             if((i+1)%2)
                printf("palavra %d: %s\n", i+1, matrstr[i]);
          break;
       case 3:
          break;
       default:
          printf("OPCAO INVALIDA!!! Digite novamente.\n");
    }
    system("pause");
    system("cls");
 }while(opcao != 3);
}
 
void preenche_matrstr(char matriz[][30]){
 int i;
 
 printf("PREENCHENDO UMA MATRIZ DE STRINGS:\n\n");
 for(i = 0; i < QTDSTR; i++){
    printf ("Digite uma palavra para a posicao %d: ", i+1);
    gets(matriz[i]);
 }
 system("cls");
}


Este código preenche uma matriz de strings com palavras digitadas pelo usuário, e depois apresenta um menu onde ele escolhe se deseja ver as palavras nas posições pares ou ímpares.
As matrizes de strings são conceitos muito simples. Mas que podem ficar muito complicados se incluirmos ponteiros na brincadeira.

Ponteiros x Matrizes
Você deve lembrar de quando apresentei o conceito de matriz (aqui), como sendo um vetor de vetores.
Também deve estar lembrado sobre a forma como alocamos um vetor dinamicamente usando a função malloc e um ponteiro (aqui). Portanto, a declaração de um vetor com o comando abaixo é muito comum:

 char* str;

E o que você diria ao se deparar com a declaração abaixo:

 char** matrstr;

Ela assusta no início. Mas depois que conhecemos o seu significado fica fácil (assim eu espero rsrs).

Apontando para quem já está apontando
O comando acima declara um ponteiro para um ponteiro de char (???). Antes que você pense que usando ele estamos declarando uma matriz, eu já quero deixar bem claro que não. O comando acima não declara uma matriz.

Observe o código abaixo:


#include <stdio.h>
#include <stdlib.h>
 
int main(){
 char** matriz;
 char matrstr[5][30];
 
 printf("O tamanho de char* matriz eh %d.\n", sizeof(matriz));
 printf("O tamanho de char matrstr[1][1] eh %d.\n", sizeof(matrstr));
 system("pause");
}


Como demonstrado no código acima, ao receber uma declaração de um ponteiro para ponteiro (ou mesmo um ponteiro simples), o compilador reversa espaço para armazenar um endereço (aqui na minha máquina esse espaço é de 4 bytes). Já quando recebe a declaração de uma matriz, ele reserva espaço para toda a matriz. Neste caso especificamente, são reservados 150 bytes.
Mas, assim como podemos tratar um endereço para um bloco de memória como um vetor, podemos fazer o mesmo com uma matriz, como inclusive já vimos na 2a parte desta série. (A diferença no post de hoje é que vamos expandir um pouco mais o conceito.)
Para isso, devemos alocar dinamicamente um bloco de memória com tamanho suficiente para armazenar nossa matriz inteira, e depois alocar, dentro deste bloco, os espaços para conter cada 'linha' da nossa matriz individualmente.
Vamos ao código:


#include <stdio.h>
#include <stdlib.h>
 
char** preenche_matrstr(int*, int*);
 
int main (){
 char **matrstr;
 int qtdstr, tamanho, i, opcao;
 
 matrstr = preenche_matrstr(&qtdstr, &tamanho);
 do{
    printf("Escolha uma das opcao abaixo:\n\n");
    printf("1. Exibir posicoes pares\n");
    printf("2. Exibir posicoes impares\n");
    printf("3. Sair\n\nopcao: ");
    scanf("%d", &opcao);
    switch(opcao){
       case 1:
          for(i = 0; i < qtdstr; i++)
             if(!((i+1)%2))
                printf("palavra %d: %s\n", i+1, *(matrstr+i));
          break;
       case 2:
          for(i = 0; i < qtdstr; i++)
             if((i+1)%2)
                printf("palavra %d: %s\n", i+1, matrstr[i]);
          break;
       case 3:
          break;
       default:
          printf("OPCAO INVALIDA!!! Digite novamente.\n");
    }
    system("pause");
    system("cls");
 }while(opcao != 3);
 for(i = 0; i < *qtd; i++){
    free(matrstr[i]);
 free(matrstr);
}
 
char** preenche_matrstr(int* qtd, int* tam){
 char** matriz;
 int i;
 
 printf("Digite a quantidade de strings da matriz: ");
 scanf("%d", qtd);
 printf("Digite o tamanho maximo de cada string: ");
 scanf("%d", tam);
 
 matriz = (char **) malloc (*qtd);
 if (!matriz){
    printf("NAO FOI POSSIVEL ALOCAR A MATRIZ.\n");
    exit(0);
 }
 else
    for(i = 0; i < *qtd; i++){
       *(matriz + i) = (char*) malloc (*tam);
       if (!(*(matriz + i))){
          printf("NAO FOI POSSIVEL ALOCAR A STRING %d.\n", i+1);
          exit(i);
       }
    }
 
 printf("PREENCHENDO UMA MATRIZ DE STRINGS:\n\n");
 setbuf(stdin, NULL);
 for(i = 0; i < *qtd; i++){
    printf ("Digite uma palavra para a posicao %d: ", i+1);
    gets(matriz [i]);
 }
 system("cls");
 return matriz;
}


Como a matriz será armazenada dinamicamente, demos ao usuário a possibilidade de escolher quantas serão e qual o tamanho máximo das strings da matriz.
Observe que em alguns pontos do código eu usei matriz[i] e em outros eu usei *(matriz+i). Foi simplesmente para mostrar que os 2 são equivalentes. Não é prático, misturar duas notações diferentes em um mesmo código. Escolha uma delas e use em todo o código.

OBS: Existe um comando novo neste código (setbuf), mas não comentarei sobre ele agora. No próximo post falaremos detalhadamente sobre ele.

Até o próximo post.

domingo, 10 de janeiro de 2010

Matrizes. Parte III (transposta/determinante)

Agora que já conhecemos as matrizes, vamos ver algumas operações com matrizes.

Transpondo uma matriz quadrada
Vamos começar criando uma matriz transposta de uma matriz quadrada 3x3. Não sabe o que é matriz transposta? Veja aqui.
Olhando a primeira vista podemos pensar que seria só trocar a posição dos elementos. Algo que o fragmento de código abaixo faria sem problemas.


 for(i = 0; i < colunas; i++)
    for(j = 0; j < colunas; j++){
       aux = mat[i][j];
       mat[i][j] = mat[j][i];
       mat[j][i] = aux;
 }


Se você tiver a curiosidade pode implementar este código. E vai ter uma triste surpresa (rsrs).
Será que você pode dizer por que este código não funciona?

Como você já descobriu, este código funciona (compila e executa), mas não faz o que se esperava que fizesse. Na verdade, ele troca a posição dos elementos do vetor e, depois, os retorna para as posições iniciais. Ele não sabe quando os elementos não precisam ser trocados, ou porque já foram, ou porque realmente não é necessário, como é o caso dos elementos da diagonal principal da matriz.
No caso da diagonal principal é fácil, basta saber se o número da coluna é igual ao da linha. E no outros casos? Como evitar que a troca seja feita novamente, fazendo o elemento voltar para a sua posição inicial?
Vamos fazer um teste de mesa (ou chinês, como preferirem) e ver como as trocas são feitas.
Linha = 0, Coluna = 0 => Diagonal principal, não precisa trocar;
Linha = 0, Coluna = 1 => Troca o elemento com o da Linha = 1, Coluna = 0;
Linha = 0, Coluna = 2 => Troca o elemento com o da Linha = 2, Coluna = 0;

Linha = 1, Coluna = 0 => A troca já foi feita, não precisa trocar;
Linha = 1, Coluna = 1 => Diagonal principal, não precisa trocar;
Linha = 1, Coluna = 2 => Troca o elemento com o da Linha = 2, Coluna = 1;
Linha = 2, Coluna = 0 => A troca já foi feita, não precisa trocar;
Linha = 2, Coluna = 1 => A troca já foi feita, não precisa trocar;
Linha = 2, Coluna = 2 => Diagonal principal, não precisa trocar;

Observando as linhas em negrito, que mostram as trocas que precisam ser realmente feitas, podemos encontrar algo em comum entre elas. Já percebeu?

O número da linha é menor que o da coluna! Agora ficou fácil, né?
Veja abaixo como fica o código completo que faz a transposição de uma matriz quadradra 3x3.


#include <stdio.h>
#include <stdlib.h>
 
const int LINHAS = 3;
const int COLUNAS = 3;
 
void preenche_mat_int(int [][3]);
void exibe_mat_int(int [][3]);
void transpor_mat_int(int [][3]);
 
int main(){
 int matriz[3][3];
 
 preenche_mat_int(matriz);
 exibe_mat_int(matriz);
 transpor_mat_int(matriz);
 exibe_mat_int(matriz);
 system("pause");
}
 
int ler_int(){
 int digitado;
 
 printf("Digite um valor inteiro: ");
 scanf("%d",&digitado);
 return digitado;
}
 
void mostra_int(int num){
 printf("%d ",num);
}
 
void preenche_mat_int(int mat[][3]){
 int i, j;
 
 printf("\nPREENCHENDO A MATRIZ:\n");
 for(i = 0; i < LINHAS; i++)
    for(j = 0; j < COLUNAS; j++)
       mat[i][j] = ler_int();
}
 
void exibe_mat_int(int mat[][3]){
 int i, j;
 
 printf("\n");
 for(i = 0; i < LINHAS; i++){
    for(j = 0; j < COLUNAS; j++)
       mostra_int(mat[i][j]);
    printf("\n");
 }
 printf("\n\n");
}
 
void transpor_mat_int(int mat [][3]){
 int i, j, aux;
 
 printf("\nTRANSPOSICAO DA MATRIZ:\n");
 for(i = 0; i < LINHAS; i++)
    for(j = 0; j < COLUNAS; j++)
       if((i != j) && (i < j)){
          aux = mat[i][j];
          mat[i][j] = mat[j][i];
          mat[j][i] = aux;
       }
}


Determinante de uma matriz quadrada 2x2
Outra função comum no trabalho com matrizes é o cálculo do seu determinante. Veja o que é, e como é feito aqui.
O código abaixo calcula o determinante de uma matriz quadrada 2x2.


#include <stdio.h>
#include <stdlib.h>
 
const int LINHAS = 2;
const int COLUNAS = 2;
 
void preenche_mat_int(int [][2]);
void exibe_mat_int(int [][2]);
int determ_mat_int_2x2(int [][2]);
 
int main(){
 int matriz[2][2], det;
 
 preenche_mat_int(matriz);
 exibe_mat_int(matriz);
 det = determ_mat_int_2x2(matriz);
 printf("O determinante da matriz informada = %d\n", det);
 system("pause");
}
 
int ler_int(){
 int digitado;
 
 printf("Digite um valor inteiro: ");
 scanf("%d",&digitado);
 return digitado;
}
 
void mostra_int(int num){
 printf("%d ",num);
}
 
void preenche_mat_int(int mat[][2]){
 int i, j;
 
 printf("\nPREENCHENDO A MATRIZ:\n");
 for(i = 0; i < LINHAS; i++)
    for(j = 0; j < COLUNAS; j++)
       mat[i][j] = ler_int();
}
 
void exibe_mat_int(int mat[][2]){
 int i, j;
 
 printf("\n");
 for(i = 0; i < LINHAS; i++){
    for(j = 0; j < COLUNAS; j++)
       mostra_int(mat[i][j]);
    printf("\n");
 }
 printf("\n\n");
}
 
int determ_mat_int_2x2(int mat[][2]){
 
 return (mat[0][0] * mat[1][1]) - (mat[0][1] * mat[1][0]);
}


É possível calcular o determinante de uma matriz quadrada de qualquer ordem, mas para isto precisamos ver um conceito que ainda não vimos. Voltarei a este assunto mais a frente.

Até o próximo post.

sábado, 9 de janeiro de 2010

Matrizes. Parte II (funções/alocação)

Continuando nossa série sobre matrizes, hoje vamos ver algumas operações básicas com matrizes.

Matrizes x Funções
Por serem intimamente relacionadas com os vetores, a operações entre matrizes e funções é praticamente idêntica, salvo o fato de termos uma (ou muitas) dimensão(ões) a mais.
Vamos ao código e você vai entender.


#include <stdio.h>
#include <stdlib.h>
 
const int LINHAS = 2;
const int COLUNAS = 2;
 
void preenche_mat_int(int [2][2]);
void exibe_mat_int(int [][2]);
 
int main(){
 int matriz[2][2];
 
 preenche_mat_int(matriz);
 exibe_mat_int(matriz);
 system("pause");
}
 
int ler_int(){
 int digitado;
 
 printf("Digite um valor inteiro: ");
 scanf("%d",&digitado);
 return digitado;
}
 
void mostra_int(int num){
 printf("%d ",num);
}
 
void preenche_mat_int(int mat[2][2]){
 int i, j;
 
 printf("\nPREENCHENDO A MATRIZ:\n");
 for(i = 0; i < LINHAS; i++)
    for(j = 0; j < COLUNAS; j++)
       mat[i][j] = ler_int();
}
 
void exibe_mat_int(int mat[][2]){
 int i, j;
 
 printf("\n");
 for(i = 0; i < LINHAS; i++){
    for(j = 0; j < COLUNAS; j++)
       mostra_int(mat[i][j]);
    printf("\n");
 }
 printf("\n\n");
}


O código acima tem bastante novidade!
A 1a delas é o uso de protótipos de função. Eu já deveria ter falado sobre eles, quando falei sobre funções (aqui), mas nunca é tarde (rsrs).

Faça sem saber como.
Em todos os códigos que vimos até agora usando funções, sempre criamos as funções antes de chamá-las na main. O código da nossa função main era sempre o último e, assim, as funções já eram 'conhecidas' dela.
No entanto é possível criar a main antes das outras funções. O único requisito é informar como essas funções serão chamadas, quais o seus retornos e parâmetros.
Esta é a função dos protótipos. Eles se parecem com o cabeçalho das funções, exceto que o nome dos parâmetros pode ser omitido.

A 2a novidade, que já aparece nos protótipos, é a forma de passar uma matriz para uma função. Deve ser informado o tipo de dados contido na matriz e o tamanho de suas dimensões. O tamanho da 1a dimensão pode ser omitido, somente da 1a. Se a matriz tiver 3 dimensões, por exemplo, o tamanho das 2a e 3a dimensões tem que ser informado.
A última é a forma de 'varrer' a matriz. Usamos um for para 'varrer' as linhas e, dentro dele, um outro for para 'varrer' todas as colunas desta linha antes de passar para a próxima. Por isso a necessidade de saber quantas linhas e colunas a matriz tem.
Como as dimensões da matriz já são conhecidas é uma ótima prática criar constantes globais que armazenem estes valores, o que facilita o acesso a elas em qualquer parte do programa.

Funções x Matrizes
Da mesma forma que um vetor pode ser alocado dinâmicamente, uma matriz também pode ser. Observe o código abaixo:


#include <stdio.h>
#include <stdlib.h>
 
int ler_int(){
 int digitado;
 
 printf("Digite um valor inteiro: ");
 scanf("%d",&digitado);
 return digitado;
}
 
void mostra_int(int num){
 printf("%d ",num);
}
 
int* preenche_mat_int(int linhas, int colunas){
 int *mat=0, i, j;
 
 if ((linhas * colunas) > 0)
    mat = (int *) malloc (linhas * colunas * sizeof(int));
 if (mat){
    printf("\nPREENCHENDO A MATRIZ:\n");
    for(i = 0; i < linhas; i++)
       for(j = 0; j < colunas; j++)
          *(mat + (i * colunas) + j) = ler_int();
 }
 else
    printf("NAO FOI POSSIVEL ALOCAR A MATRIZ!!!\n");
 return mat;
}
 
void exibe_mat_int(int* mat, int linhas, int colunas){
 int i, j;
 
 printf("\n");
 for(i = 0; i < linhas; i++){
    for(j = 0; j < colunas; j++)
       mostra_int(*(mat + (i * colunas) + j));
    printf("\n");
 }
 printf("\n\n");
}
 
int main(){
 int *matriz, linhas, colunas;
 
 printf("Digite o numero de linhas da matriz (maior que zero):\n");
 linhas = ler_int();
 printf("Digite o numero de colunas da matriz(maior que zero):\n");
 colunas = ler_int();
 matriz = preenche_mat_int(linhas, colunas);
 if(matriz){
    exibe_mat_int(matriz, linhas, colunas);
    free(matriz);
 }
 system("pause");
}


A diferença básica neste código é a permitir ao usuário que defina o número de linhas e colunas da matriz, por isto não pudemos armazenar estes valores em constantes globais (observe que tivemos que passar estes valores para todas as funções). Uma vez definidas, linhas e colunas, verificamos se os valores informados foram válidos e, alocamos espaço para a matriz.
Como o bloco de memória alocado não foi definido como uma matriz, ele não pode ser indexado como uma, usando os []. A solução para isso é o uso de ponteiros e da aritmética de ponteiros.
A linha 25 mostra como isto é feito. Observe a multiplicação de i, que contém o número da linha atual, pela quantidade de colunas. Dá pra entender o porquê, certo?

Por hoje é isto. Até o próximo post.

sexta-feira, 8 de janeiro de 2010

Matrizes. Parte I (conceitos)

Hoje vamos começar a falar sobre um tipo de vetor especial: um vetor de vetores, a matriz.

Vetor de vetores?
Como já sabemos, vetor é um agrupamento sequencial de variáveis do mesmo tipo. O mais comum deles é um deste tipo que você está lendo aqui: um vetor de caracteres (as famosas strings). Confirmando o conceito: várias letras (olha o mesmo tipo aí) em sequência (olha a sequência aí). Podemos ter vetores de vários tipos de dados, inclusive de outros vetores.
Vou desenhar, assim você vai entender melhor.



Na figura acima, temos a representação de como é armazenado em memória um vetor que está armazenando outros 4 vetores.
Na verdade, esta divisões internas não existem(???). Este vetor de vetores, corresponde a um único vetor com 16 elementos. Então qual a razão dessa divisão?
A resposta é PRATICIDADE.
Lembra do lema 'Dividir para conquistar' que vimos aplicado às funções? Esta é a sua aplicação nos vetores. É muito mais fácil, visualizar cada pequeno bloco de cada vez do que todo o conjunto. Tanto é assim, que apesar deste vetor ser armazenado como na figura acima, nos referimos a ele, como se estivesse armazenado como na figura abaixo:



Agora passamos a enxergar o nosso vetor de vetores na forma de linhas, onde cada 'linha' armazena um vetor.
Olhando para esta representação, podemos notar que os elementos dos vetores armazenados nas 'linhas', parecem formar 'colunas'. Então, com o intuito de, mais uma vez, facilitar nossa visualização, chegamos a representação do nosso vetor de vetores de uma forma, espero, conhecida: a matriz. Observe a figura abaixo:



Esta é uma matriz de duas dimensões (linhas e colunas, ou eixos x e y). Não existem limites para o número de dimensões que uma matriz possa ter, embora quanto mais dimensões, mais trabalhosa é a operação com a matriz. As mais comuns são as de duas e três dimensões (páginas, linhas e colunas, ou eixos x, y e z).
Uma representação de uma matriz de 3 dimensões seria como na figura abaixo:



Agora que já vimos como uma matriz é armazenada e representada, vamos ver como é o seu uso em C.

As matrizes e o C
Para definir uma matriz em C, devemos informar o seu tipo, nome e os tamanhos de cada uma das suas dimensões.

 <tipo> nome [tamanho_dimensão1] [tamanho_dimensão2]...[tamanho_dimensãoN];

Para a matriz representada pelas figuras acima, uma matriz com 4 linhas e 4 colunas, que é do tipo inteiro, por exemplo, o comando seria:

  int matriz [4][4];

Assim, para atribuir o valor do elemento da 2a linha e 3a coluna, por exemplo, a uma variável inteira num, o comando é:

  num = matriz[1][2];

Assim como os vetores, o índice base de uma matriz também é 0 (zero). Então, a 2a linha é a de índice 1, e a 3a coluna é a de índice 2.

Fácil, não.
No próximo post veremos algumas operações com matrizes. Até lá.

domingo, 3 de janeiro de 2010

Funções x Vetores. Parte Final (código)

Agora que já vimos os conceitos e como funciona a alocação dinâmica, estamos prontos para ver um código exemplo. Então vamos a ele.


#include <stdio.h>
#include <stdlib.h>
 
int ler_int(){
  int digitado;
 
 printf("Digite um valor inteiro: ");
 scanf("%d",&digitado);
 return digitado;
}
 
void mostra_int(int num){
 printf("%d ",num);
}
 
void exibe_vetor(int* vet, int tamanho){
 int i;
 
 printf("\n");
 for(i = 0; i < tamanho; i++)
    mostra_int(vet[i]);
 printf("\n\n");
}
 
int* preenche_vet_int(int tamanho){
 int *vet=0, i;
 
 vet = (int *) malloc (tamanho * sizeof(int));
 if (vet){
    printf("\nPREENCHENDO O VETOR:\n");
    for(i = 0; i < tamanho; i++)
       vet[i] = ler_int();
 }
 return vet;
}
 
int aumenta_vet_int(int* vet, int* tamanho, int incremento){
 int novo_tam, i;
 
 novo_tam = *tamanho + incremento;
 vet = (int *) realloc (vet, novo_tam * sizeof(int));
 if (vet){
    printf("\nPREENCHENDO OS NOVOS ITENS DO VETOR:\n");
    for(i = *tamanho; i < novo_tam; i++)
       vet[i] = ler_int();
    *tamanho = novo_tam;
    return 1;
 }
 else{
    printf("NAO FOI POSSIVEL AUMENTAR O VETOR!\n");
    return 0;
 }
}
 
int diminui_vet_int(int* vet, int* tamanho, int decremento){
 int novo_tam, i;
 
 novo_tam = *tamanho - decremento;
 if (novo_tam <= 0){
    printf("DECREMENTO INFORMADO INVALIDO!!! NAO FOI POSSIVEL DIMINUIR O VETOR!\n");
    return 0;
 }
 vet = (int *) realloc (vet, novo_tam * sizeof(int));
 if (vet){
    *tamanho = novo_tam;
    return 1;
 }
 else{
    printf("NAO FOI POSSIVEL DIMINUIR O VETOR!\n");
    return 0;
 }
}
 
int main(){
 int *vetor, tamanho, incremento, decremento;
 
 printf("Digite o tamanho do vetor:\n");
 tamanho = ler_int();
 vetor = preenche_vet_int(tamanho);
 if (vetor){
    exibe_vetor(vetor, tamanho);
    printf("Digite o quanto deseja aumentar o vetor:\n");
    incremento = ler_int();
    if (aumenta_vet_int(vetor, &tamanho, incremento))
       exibe_vetor(vetor, tamanho);
    printf("Digite o quanto deseja diminuir o vetor:\n");
    decremento = ler_int();
    if (diminui_vet_int(vetor, &tamanho, decremento))
       exibe_vetor(vetor, tamanho);
    free(vetor);
 }
 else
    printf("NAO FOI POSSIVEL ALOCAR O VETOR!\n");
 system("pause");
}


Depois do que já vimos nos post anteriores, este código ficou muito simples.
Algumas funções já são conhecidas nossas. E dentre as novas funções existe pouca coisa que ainda não foi dita.
A primeira função nova está na linha 25, e é a razão desta sequência de posts. É uma função que retorna um vetor. Um detalhe interessante dela é que damos ao usuário a liberdade de definir o tamanho deste vetor. Seu funcionamento é simples.
Declaramos um ponteiro para inteiros vet e o inicializamos com o valor 0. Este ponteiro irá armazenar o endereço do vetor que será alocado dinamicamente.
Fazemos uma chamada a função malloc com o tamanho definido pelo usuário, e atribuimos o seu retorno ao ponteiro vet.
Se a chamada teve sucesso e o vetor foi alocado, imediatamente vamos preenchê-lo.
Observe o uso do if sem nenhum operador relacional. Na verdade ele verifica o valor de vet. Por isso o inicializamos com 0. Se a função malloc falhou, o valor de vet ainda será 0 (se funcionar perfeitamente, malloc nunca retorna um endereço 0). Este if verifica se o valor de vet é diferente de 0 (cuidado com isto: por diferente entenda qualquer outro valor, inclusive negativo). Este uso do if é muito comum, e passaremos a usá-lo, sempre que possível, daqui pra frente, como pode ser visto nas linhas 84 e 88, onde ele avalia o valor retornado pelas funções que aumentam e diminuem o tamanho do vetor, respectivamente.
A segunda nova função, na linha 37, aumenta o tamanho do vetor com um valor também definido pelo usuário, usando a função realloc. Observe que usando um ponteiro para a variável tamanho, podemos alterar o seu valor dentro da própria função.
A última função nova, na linha 55, diminui o tamanho do vetor de forma semelhante à função que o aumenta, usando a função realloc com um valor definido pelo usuário. A diferença entre elas é a verificação da validade do valor informado pelo usuário, evitando um erro ao tentar alterar o tamanho do vetor para 0 ou um valor negativo.
Observe que na linha 90, já na função main, desalocamos o bloco de memória usado pelo vetor. Isto é muito importante, se não este espaço ficará 'ocupado' mesmo após o término do programa.

Com isto encerramos a nossa série sobre funções que retornam vetores e como isto é possível utilizando a alocação dinâmica.
Alguma dúvida?

sábado, 2 de janeiro de 2010

Funções x Vetores. Parte II (alocação dinâmica)

Hoje vamos ver mais a fundo os conceitos que falamos no post anterior.

Alocando memória em C
A função especifica em C para alocar memória é a malloc (memory allocation). Esta função aloca (reserva) uma área sequêncial na memória heap com a quantidade de bytes especificada, e retorna o endereço da mesma. A sua sintaxe é esta:

 malloc (tamanho);

onde tamanho é a quantidade de bytes que se deseja alocar.

No entanto, devemos lembrar, que os tipos de dados básicos do C ocupam mais de 1 byte, com a excessão do tipo char. Como não temos como precisar quantos bytes exatamente cada computador (micro, celular, etc.) utiliza para armazenar cada um destes tipos básicos, é necessário fazer uma operação chamada de conversão de tipo (type casting) explícita.

Convertendo tipos
Já vimos que a divisão de 2 inteiros, nem sempre retorna 1 outro inteiro (por exemplo: 2/3).
Para resolver este problema, a solução mais simples seria declarar as variáveis envolvidas nesta divisão como floats ao invés de inteiros. Mas há casos em que esta alteração de tipos nem sempre é possível, como é o caso da função malloc, por exemplo.
Esta função retorna, a grosso modo, o endereço de um vetor de char com a quantidade especificada. Não temos como alterar esta função, mas temos como alterar o seu retorno.
Veja no código abaixo como podemos resolver a questão da divisão usando uma conversão de tipos.


#include "stdio.h"
#include "stdlib.h"
 
int main(){
 int a = 3, b = 2;
 float c;
 
 c = (float)a/b;
 printf("%.2f\n", c);
 system("pause");
}


Observe a linha 8. Esta é a forma de converter um tipo explicitamente em C. Neste caso estamos alterando o tipo da variável a de inteiro para float, o que garante que o resultado da divisão também será um float.

Voltando à alocação dinâmica...
Agora que sabemos como é feita uma alteração de tipos em C, podemos alterar a forma de chamar a função malloc.

 (<tipo de retorno> *) malloc (tamanho * sizeof(<tipo que será armazenado>);

Duas coisas chamam a nossa atenção no comando acima.
A primeira é o * dentro dos () que fazem a alteração do tipo de retorno. Ele é necessário porque a função malloc não retorna um tipo básico, mas sim um endereço que aponta para um bloco de memória que irá armazenar variáveis deste tipo básico, ou seja, um ponteiro para este bloco.
A segunda é o uso da função sizeof dentro dos () onde é informado o tipo dos dados que serão armazenados. A função sizeof nos retorna o número de bytes necessários, no computador utilizado, para armazenar o tipo de dado especificado.
Se quisermos alocar um espaço suficiente para conter 30 inteiros e atribuir este espaço a um vetor, os comandos usados seriam:

 int* vet;
 vet = (int *) malloc (30 * sizeof(int));

E se o espaço ainda não for suficiente?
Não haveria sentido em se chamar alocação dinamica, se não pudéssemos alterar dinamicamente o tamanho do vetor. E como fazer isto?
A resposta está na função realloc (reallocation). Ela é funciona básicamente como a função malloc. A diferença é que ela altera o tamanho de um bloco já alocado pela função malloc. Observe bem isto! Não é possível alterar o tamanho de um bloco com a função realloc se antes ele não tiver sido alocado com a função malloc!
Para alterar o tamanho do vetor do comando acima, de 30 para 50 inteiros, o comando seria este:

 vet = (int *) realloc (vet, 50 * sizeof(int));

Observe que a diferença básica é que informamos qual o bloco que será alterado dentro dos () antes de informarmos o novo valor.
Um detalhe interessante, é que se já houverem valores armazenados no bloco/vetor que terá seu tamanho alterado, eles não serão perdidos, desde que o bloco tenha o seu tamanho aumentado. Se o tamanho for reduzido, serão perdidos os valores armazenados no final do bloco.

Recolhendo o lixo.
Nós vimos que as variáveis locais só existem enquanto as funções estão em execução, e que depois disso elas são eliminadas. As variáveis globais só existem enquanto o programa está em execução, e depois disto elas também são eliminadas. Já com as variáveis alocadas dinamicamente isto não ocorre.
Estas variáveis ficam na memória mesmo depois que todas funções são encerradas, inclusive a main. Isso quer dizer que elas ficam na memória mesmo depois que o programa termina. Isto causa uma perda de memória. Dependendo da quantidade de memória disponível no sistema isto pode fazer com que o sistema pare.
(Algumas linguagens de programação se encarregam de eliminar essas variáveis quando o programa se encerra. Isto é chamado de coletor de lixo (garbage colletor). Não é o caso de C/C++.)
Só existem duas formas de recuperar esta memória.
A primeira forma, e mais drástica, é reiniciando o sistema. Mas, assim que o programa for executado novamente, a memória será perdida novamente.
A segunda forma, e correta, é usando a função free.
A função free desaloca um bloco de memória alocado pela função malloc, marcando esta área como memória livre.
Para desalocar o vetor que estamos usando como exemplo, o comando seria este:

 free(vet);

No próximo e, acredito, último post desta série, veremos isto funcionando na prática. Até lá.

sexta-feira, 1 de janeiro de 2010

Funções x Vetores. Parte I (conceitos)

Antes de mais nada, gostaria de desejar um 2010 de muitas realizações e conquistas!

Vamos começar o ano falando sobre algo muito importante.
Eu estava esperando alguém perguntar. Mas já que ninguém perguntou... Eu pergunto.
É possível que uma função retorne um vetor?

A resposta é SIM e NÃO (rsrs).

Vamos entender o porquê disto.

No exemplo sobre vetores e funções que vimos até agora (aqui) sempre declaramos o vetor na função main e passamos por referência para as outras funções.
O que aconteceria se fizermos o contrário?
NÃO FUNCIONARIA!

Quando declaramos uma variável dentro de uma função (inclusive vetores), ela é local à função e não é visível por nenhuma outra função e, mais ainda, ela só existe enquanto a função está 'ativa'.
Mas por que funciona com a função main?
A função main é especial. Ela é quem coordena o funcionamento de todas as outras funções, e é a única função que está disponível do início ao fim da execução do programa (podemos ter várias chamadas a outras funções, mas a main só é chamada uma única vez, no início do programa, que começa por ela). Uma variável declarada na main (inclusive vetores) pode ser passada para qualquer outra função por referência, se assim for a vontade do programador.
Uma forma de contornar esta limitação imposta pela modularidade seria armazenando as variáveis em um local onde elas pudessem ser acessadas mesmo sendo declaradas dentro de uma função. Isso existe!
Para entender como isso é feito temos que explicar como o C trata a memória do computador. Observe a figura abaixo:



Olhando a figura podemos notar que o C 'divide' a memória que é usada por um programa em 3 partes distintas.
- A pilha, onde são armazenadas as variáveis locais;
- A memória estática, onde são armazenadas as variáveis globais;
- O heap, onde são armazenadas as variáveis alocadas dinamicamente. (???)


Variáveis alocadas dinamicamente
Imagine que tenhamos que armazenar um vetor que não sabemos que tamanho terá? Já vimos que geralmente se escolhe um tamanho que se considere razoável, que na grande maioria dos casos, é maior que o tamanho necessário.
Para resolver isto foi criada a alocação dinâmica.
Alocação dinâmica nada mais é que obter espaço na memória para uma variável (leia-se estrutura de dados) a medida que ele for necessário.
Como vimos na figura acima, o espaço onde essas variáveis ficam armazenadas é um espaço separado.
Como já falamos, se sabemos o endereço de uma variável podemos ter acesso à ela, e o nome de um vetor 'corresponde' ao seu endereço.
No próximo post veremos como isto é feito na prática. Até lá