Pesquisar no blog:

terça-feira, 26 de março de 2013

Estrutura condicional if, else, else if (Linguagem C)

A estrutura condicional if é conhecida em todas as linguagens de programação. Sua estrutura muda pouco de uma linguagem para outra, e, desde que você tenha uma boa lógica, é fácil usa-lá.
A estrutura condicional está no seu dia-a-dia. Antes de sair de casa, por exemplo, podemos olhar pela janela verificar como está o tempo: se o tempo estiver nublado e com nuvens carregadas, levarei o guarda-chuva.
É exatamente dessa mesma forma que funciona a estrutura condicional de uma linguagem de programação. Posso através dele verificar se um determinado valor é igual (==) ao valor de outra variável, se é maior (>), se é menor, maior igual (>=) ou menor igual (<=). A verificação que farei vai depender do valor que eu desejo que seja retornado.
Antes de usar a estrutura condicional if é importante que você entenda os operadores relacionais e os operadores lógicos.


if - Estrutura simples:


A estrutura simples contém apenas uma condição. Se está condição for verdadeira (1) o programa executa sua(s) instrução(ões).
Exemplos:
main()
{
 int a, b;
 printf("Informe 2 valores inteiros: ");
 scanf("%d %d", &a, &b);
 if(a>b)
  printf("A variavel a eh maior que b\n");
 system("pause");
}
Nesse código o usuário entra com os valores da variável a e da variável b e dentro da estrutura condicional é comparado se a é maior que b. Se verdadeiro o programa retorna a mensagem: "A variável a eh maior que b", ou continua em system("pause");. Se houvesse mais linhas abaixo da estrutura condicional o programa continuaria a execução. Exemplo:
main()
{
 int a, b;
 printf("Informe 2 valores inteiros: ");
 scanf("%d %d", &a, &b);
 if(a>b)
  printf("A variavel a eh maior que b\n");
 printf("Nesta estapa o programa ja esta fora da estrutura condicional.\n");
 printf("Pressione uma tecla...\n\n");
 getch();
 printf("O programa encerrara.\n");
 system("pause");
}
Nesse exemplo a estrutura condicional executa uma única instrução. Quando há mais de uma instrução a ser executada devemos fazer uso das chaves:
if(condição)
{
instrução1;
instrução2;
...;
 instruçãoN;
}
Obs.: se a estrutura condicional possuir apenas uma instrução também é permitido o uso da chave.
Exemplo:
main()
{
 int a, b, aux;
 printf("Informe 2 valores inteiros: ");
 scanf("%d %d", &a, &b);
 if(a>b)
 {
  aux = a;
  a = b;
  b = aux;
 }
 printf("Os números foram ordenados: %d, %d\n\n", a, b);
 printf("O programa encerrara.\n");
 system("pause");
}
No código acima se a primeira variável (a) for maior que a segunda (b) o programa inverte seus valores para imprimi-las na ordem.

if, else - Composta:

A estrutura composta faz uso do else (senão), indicando outra(s) condição(ões) caso a primeira não seja executada.
Exemplo:
main()
{
 char cor;
 printf("Escolha uma cor: \n0: Preto\n1: Azul\n2: Verde\n");
 scanf("%c", &cor);
 if(cor == '0')
 {
  system("color 0");
  printf("Voce escolheu a cor preta.\n");
    }
 else if(cor == '1')
 {
  system("color 1");
  printf("Voce escolheu a cor azul.\n");
    }
 else if(cor == '2')
 {
  system("color 2");
  printf("Voce escolheu a cor verde.\n");
    }
 else
  printf("Invalido.\n");
 printf("\nO programa sera encerrado.\n");
 system("pause");
}

No código acima é feita a primeira condição if(cor == '0'), se esta não for verdadeira então é passada para a segunda condição else if(cor == '1'), se esta não for verdadeira é passado para a terceira else if(cor == '2') e por fim colocamos apenas um else que indica que se não for nenhuma da alternativas anteriores será dada a mensagem "Invalido".
Apenas UMA das condições pode ser executada, e assim que uma delas for executada o programa é jogado para fora da estrutura condicional. Observe que toda a estrutura condicional do código acima faz parte de uma unica estrutura, outra seria aberta se iniciássemos outro if.

if, else - Estrutura aninhada:

A estrutura aninhada é, basicamente, um if dentro de outro. Ou seja, se a primeira condição for verdadeira (1) poderei ter uma segunda condição, terceira, quarta, etc.
Exemplo:
main()
{
 int a = 0, b = 2, c = 0, d = 10, e = -8;
 if((a == 0) && (b == 2))
 {
  if(c > 0)
   printf("Comando 1\n");
  else if(d >= 10)
  {
   if(e < 0)
    printf("Comando 2\n");
   else
    printf("Comando 3\n");
  }
        }
    printf("O programa sera encerrado.\n");
    system("pause");
}

main()
{
 int a = 0, b = 2, c = 0, d = 10, e = -8;
 if((a == 0) && (b == 2))
 {
  if(c > 0)
   printf("Comando 1\n");
  else if(d >= 10)
  {
   if(e < 0)
    printf("Comando 2\n");
   else
    printf("Comando 3\n");
  }
        }
    printf("O programa sera encerrado.\n");
    system("pause");
}
Observe que neste código a 3 estruturas condicionais uma dentro da outra. A estrutura azul está dentro da estrutura verde que está dentro da estrutura vermelha. Sendo assim a estrutura na cor verde só é executa se a estrutura vermelha for verdadeira e a estrutura azul só é executada se a primeira condição da estrutura verde (if(c > 0)) for falsa e a segunda (else if(d >= 10)) verdadeira.
Os operadores lógicos podem ser usados para simplificar seu código fonte, não havendo necessidade de criar estruturas condicionais aninhadas tão complexas.
É importante você testar todos os possíveis fluxos do seus dados, evitando erro de lógica. Para isso podemos usar a depuração (Debugging).
Há ainda a estrutura switch / case, que faz uma função parecida com a da estrutura if, mais em alguns casos pode ser mais adequada e mais legível.

segunda-feira, 25 de março de 2013

Operadores lógicos - Linguagem C

Os operadores lógicos são de extrema importância para qualquer programador. Eles são muito utilizados em conjunto dos operadores relacionais, então, se você ainda não sabe como usa-los acesse: Operadores relacionais.
Operadores lógicos:
Operador
Leitura
&&
And (E)
||
Or (Ou)
!
Not (Não)


&&: o operador And (E) pode verificar diversas comparações feitas com os operadores relacionais. Ele retornará Verdadeiro (1) sempre que TODAS as comparações forem verdadeiras, se uma das expressões for falsa o valor retornado será Falso (0).
Ou seja:
Verdadeiro E Verdadeiro = Verdadeiro
Verdadeiro E Falso = Falso
Falso E Falso = Falso
Exemplos:
a) (5<=5)&&(2<4) = 1
Resolução a) (Verdadeiro)&&(Verdadeiro) = Verdadeiro

b) (2<4)&&(1>5) = 0
Resolução a) (Verdadeiro)&&(Falso) = Falso


c) (5<=5)&&(2<4)&&(2>4) = 0
Resolução a) (Verdadeiro)&&(Verdadeiro)&&(Falso) = Falso

||: o operador Or (Ou) pode verificar diversas comparações feitas com os operadores relacionais. Ele retornará Verdadeiro (1) se pelo menos uma das expressões for verdadeira e Falso (0) quando todas as expressões forem falsas.
Ou seja:
Verdadeiro Ou Verdadeiro = Verdadeiro
Verdadeiro Ou Falso = Verdadeiro
Falso Ou Falso = Falso
Exemplos:
a) (5<=5)||(2<4) = 1
Resolução a) (Verdadeiro)||(Verdadeiro) = Verdadeiro

b) (2<4)||(1>5) = 1
Resolução a) (Verdadeiro)||(Falso) = Verdadeiro

c) (3<3)||(2<4)||(2>4) = 0
Resolução a) (Falso)||(Verdadeiro)||(Falso) = Verdadeiro

d) (3<3)||(3<1)||(2>4) = 0
Resolução a) (Falso)||(Falso)||(Falso) = Falso

!: o operador Not (Não / Negação) inverte um valor Verdadeiro (1) para Falso (0) ou Falso (0) para Verdadeiro (1). Simples assim: Não verdadeiro é Falso e Não falso é Verdadeiro.
Exemplos:
a) !(5<=5) = 0
Resolução a) Observe que a expressão (5<=5) é verdadeira, mais o operador Not (!) fora da expressão está fazendo sua negação. Temos então: Não(Verdadeiro) = Falso.

b) !((3==2)&&(7>5)) = 1
Resolução b) 
Observe que neste caso usamos uma expressão com o operador And (&&) e fora dele fizemos a negação (!). Acompanhe nas duas linhas abaixo a resposta:
Não((Falso)&&(Verdadeiro))
Não(Falso) = Verdadeiro

Como você observou podemos usar vários operadores dentro da mesma expressão, e isso é muito comum.
Apesar de algumas expressões parecerem complicadas, elas podem facilitar muito seu código fonte.
Lembre-se de sempre fazer o uso dos parenteses para indicar as expressões que devem ser lidar primeiro.
Veja alguns exemplos de expressões com vários operadores lógicos e acompanhe suas resoluções para praticar:
a)((2==2)&&(9>0))||((6>=6)&&(!(0<=8)))
((Verdadeiro)E(Verdadeiro)) Ou ((Verdadeiro)E(Não(Verdadeiro)))
(Verdadeiro) Ou ((Verdadeiro)E(Falso))
(Verdadeiro) Ou (Falso) = Verdadeiro

b) !(((4==2)||(-9<1)||((2<2)&&(4<8)))&&(!((6==6)&&(2==2))))
Não(((Falso)Ou(Verdadeiro)Ou(Falso))) E (Não((Verdadeiro)E(Verdadeiro))))
Não((Verdadeiro) E (Não(Verdadeiro)))
Não((Verdadeiro) E (Falso)) = Verdadeiro

Veja também:

domingo, 24 de março de 2013

Operadores Relacionais - Linguagem C

Os operadores relacionais são utilizados para fazer comparações entre valores. E o computador retornará 0 (falso) ou 1 (verdadeiro). São muito utilizados dentro de estruturas condicionais para definir o fluxo dos dados.
Operadores relacionais:
Operador 
Leitura
==
Igual (comparação)
< 
Menor
<=
Menor ou igual
> 
Maior
>=
Maior ou igual

Ao fazer alguma comparação a linguagem de programação retornará FALSO ou VERDADEIRO, ou melhor, 0 ou 1.
Muita atenção no uso do operador relacional == (comparação), pois existe ainda o operador = (atribuição).
Exemplo:
main()
{
 int a = 5, b = 10;
 printf("%d\n", a==b);
 b = 5;
 printf("%d\n", a==b);
 system("pause");
}

Observe no código acima a diferença entre os operadores.
Na primeira linha dentro da função main usei o operador de atribuição duas vezes, definindo um valor para a (5) e um valor para b (10).
Depois dentro da função printf pedi a impressão de a==b, substituindo seus valores dentro do primeiro printf teriamos: 5==10, ou seja, 0 (falso).
Logo abaixo do primeiro printf usei o operador de atribuição outra vez, dizendo que a variável b passará a ter o valor 5.
Após trocar os valores usei outra vez, na próxima linha, a comparação entre a e b. Neste segundo printf temos a comparação 5==5, ou seja, 1 (verdadeiro).

Exemplos dos outros operadores relacionais:
Maior:
5>5 = 0 Leitura: (5 é maior que 5?) = Falso
5>7 = 0 Leitura: (5 é maior que 7?) = Falso
5>2 = 1 Leitura: (5 é maior que 2?) = Verdadeiro

Maior ou igual:
5>=5 = 1 Leitura: (5 é maior ou igual a 5?) = Verdadeiro
5>=7 = 0 Leitura: (5 é maior ou igual a 7?) = Falso
5>=2 = 1 Leitura: (5 é maior ou igual a 2?) = Verdadeiro

Menor:
5<5 = 0 Leitura: (5 é menor que 5?) = Falso
5<7 = 1 Leitura: (5 é menor que 7?) = Verdadeiro
5<2 = 0 Leitura: (5 é menor que 2?) = Falso

Menor ou igual:
5<5 = 1 Leitura: (5 é menor ou igual a 5?) = Verdadeiro
5<7 = 1 Leitura: (5 é menor ou igual a 7?) = Verdadeiro
5<2 = 0 Leitura: (5 é menor ou igual a 2?) = Falso

Lembre-se: 
falso: 0
verdadeiro: 1

Veja também:

quarta-feira, 13 de março de 2013

Depuração (Debugger) no Code::Blocks

Depuração é uma ferramenta disponibilizada pela maioria das IDEs para facilitar o teste de um código fonte.
Com ele você pode executar seu programa "passo-a-passo" e observar o fluxo dos seus dados dentro das estruturas if/else, switch/case, a quantidade de vezes que se está executando um  laço de repetição (for, while, do/while), verificar o valor das variáveis, acompanhar funções, etc.
Dessa forma você consegue descobrir erros lógicos. Pequenos detalhes que podem fazer seus programas não funcionar como deveria.
A depuração é de extrema importância para qualquer programador, até mesmo para os iniciantes, já que acompanhar o código linha-a-linha e fazendo seus cálculos e comparações lógicas no "dedo", em um papel ou com sua própria memória seria muito mais difícil.

Como utilizar a depuração no Code::Blocks

A depuração no Code::Blocks é bem simples de se usar. A unica coisa que você deve fazer é salvar o seus código fonte como um projeto. Apenas dessa forma você pode depurar seu programa.
Então se você já tem algum código fonte você deverá copia-lo para um arquivo que faça parte de um projeto.

IMPORTANTE: Ao criar o projeto desative a opção "Release" no assistente de novo projeto.
IMPORTANTE: O arquivo com a função principal deve se chamar "main.c" ou a depuração não funcionará!
#define TAM 10
int main(int argc, char *argv[])
{
    int i, j, aux, troca, v[TAM] = {7,0,5,1,4,2,6,3,-8,-1};
    for(i = 0; i < TAM; i++)
    {
          troca = 0;
          for(j = 0; j < (TAM-1)-i; j++)
          {
                if(v[j] > v[j+1])
                {
                    aux = v[j];
                    v[j] = v[j+1];
                    v[j+1] = aux;
                    troca = 1;
                }
          }
          if(troca == 0)
             break;
    }
    printf("\n\nOrdenado: \n");
    for(i = 0; i < TAM; i++)
    {
         printf("%d, ", v[i]);
    }
    system("pause");
    return 0;
}
Este código é uma das soluções propostas para ordenação de valores. Sendo este o mais simples de todas as soluções propostas (Bubble Sort).
Para que a depuração pare em determinados pontos você pode utilizar os breakpoints clicando na barra cinza ao lado do código fonte próximo aos números das linhas:






Para iniciar a depuração no Code::Blocks você pode utilizar a opção Debug/Start ou o atalho F8.

Observe que ao iniciar a depuração é feita uma seta amarela na linha onde o programa esta parado:


Você pode controlar a depuração através de opções oferecidas pela IDE:
Stop debugger: Para a execução do programa.
Continue: executa até o próximo breakpoint.
Next Line: executa a próxima linha.
Step into: entrar em uma função.
Step out: sair de uma função.
Start: Iniciar.
Debugging windows: Você pode acessar a opção "Debugging windows" através do meneu Debug ou pela barra de ferramentas:

Através dela você tem acesso a algumas janelas que auxiliam na visualização de Breakpoints (pontos de paradas), CPU Registers (Registradores do processador), Watcher (valores das variáveis), etc.

sexta-feira, 8 de março de 2013

Depuração (Debugger) no Dev-C++

Depuração é uma ferramenta disponibilizada pela maioria das IDEs para facilitar o teste de um código fonte.
Com ele você pode executar seu programa "passo-a-passo" e observar o fluxo dos seus dados dentro das estruturas if/else, switch/case, a quantidade de vezes que se está executando um  laço de repetição (for, while, do/while), verificar o valor das variáveis, acompanhar funções, etc.
Dessa forma você consegue descobrir erros lógicos. Pequenos detalhes que podem fazer seus programa não funcionar como deveria.
A depuração é de extrema importância para qualquer programador, e mesmo para os iniciantes já se há esse habito de depuração desde o inicio, acompanhando o código linha-a-linha e fazendo seus cálculos e comparações lógicas no dedo, ou em um papel ou com sua própria memória.

Como utilizar a depuração no Dev-C++

Antes de usar a depuração no Dev-C++ devemos configurar algumas coisas. Siga esses passos:
1- Abra o Dev-C++ e acesse Tools/Compiler Options
2- Ative a opção "Add the following commands when calling compiler" e digite o argumento -O0
3- Ative a Guia Settings opção Linker e marque para Yes a opção "Generate debugging information"
Obs.: antes de depurar seu programa é necessário que ele seja compilado.

Vou usar como exemplo o seguinte código fonte:
int main()
{
int n1,n2,n3,i,r;
n1 = 1;
n2 = 1;
for (i = 0; i < 20; i++)
{
  if (i < 2)
   printf("%d ",n1);
  else
            {
   n3 = n1 + n2;
   n1 = n2;
   n2 = n3; 
   printf("%d ",n3);
            }
}
getch();
return (0);
}
Este código é uma solução minha proposta para o problema de Fibonacci. Para saber mais sobre Fibonacci acesse este artigo do tecmundo de Wikerson Landim, muito interessante!
De forma resumida é: cada elemento, a partir do terceiro é obtido somando-se os dois anteriores.
Para que a depuração pare em determinados pontos você pode utilizar os breakpoints clicando na barra preta ao lado do código fonte:

Para iniciar a depuração no Dev-C++ você pode utilizar a opção Debug/Debug ou o atalho F8.
Você pode ainda controlar a depuração através de opções oferecidas pela IDE:
Next Step: executa a próxima instrução.
Step into: entrar em uma função.
Continue: executa até o próximo breakpoint.
Run to Cursor: executa até onde o cursor estiver posicionado.
Debug: Iniciar/Parar Depuração
Stop Execution: Para a execução do programa.
Add Watch: adiciona em um painel a esquerda do código as variáveis que você deseja visualizar o valor. Para adicionar você só precisar digitar seu nome. 
Exemplo:

Painel com valores das variáveis:
Observe que enquanto você executa a depuração seu programa fica em execução, e todo seu conteúdo aparece de acordo com os passos que são executados.
É importante que você acompanhe os valores das variáveis e o fluxo dos dados para verificar se não existem erros de lógica no seu programa.
Você pode trocar o valor de uma variável enquanto seu programa roda para testar seu funcionamento clicando com o botão direito sobre ela:

Veja também como depurar seu código em linguagem C com o Code::Blocks.

sábado, 2 de março de 2013

Compilador GCC

GNU Compiler Collection (GCC) é um conjundo de compiladores desenvolvido por Richard Stallman também fundador do projeto GNU.
Esse compilador é utilizado por várias plataformas: Windows, Linux, Unix, etc
Para desenvolver um programa em C você só precisará então de um editor de texto como o bloco de notas (Windows) ou VI (Linux). O programa escrito nesses editores devem ser salvos com a extensão ".c".
Exemplo: meu_programa.c
E este código fonte deve ser compilado pelo GCC com a seguinte linha de comando:
Windows:
Compilar: gcc -c meu_programa.c
Ao compilar é gerado um objeto que devemos "linkeditar": gcc -o meu_programa_executavel meu_programa.o
Podemos ainda gerar o executável direto: gcc -o meu_programa_executavel meu_programa.c
Linux:
Geração direta do executável: $ gcc meu_programa.c -o meu_programa_compilado

Obs.: o argumento "-o" linka o objeto gerado para o executável e logo a frente é informado o nome do programa executável.
O GCC é um compilador escrito para Unix/Linux, para instalar no Windows usaremos o MinGW (Minimalist GNU for Windows). Faça o download aqui.
Após instalar o MinGW você poderá encontrar o GCC dentro de seu diretório na pasta bin (C:\MinGW\bin).
Para facilitar a compilação e linkedição do seu programa salve seus programa nessa pasta.
Como exemplo vamos compilar o programa abaixo:
main()
{
      printf("Hello World \n");
      system("pause");
}
Salvei este programa no C:\MinGW\bin com o nome meu_programa.c
Agora para executar o programa utilizei os seguintes comando no CMD do Windows:
1- cd C:\mingw\bin
2- gcc -o meu_programa meu_programa.c

Assim gerei o executável (meu_programa.exe) dentro da pasta C:\MinGW\bin. Acesse a pasta e execute seu programa:

Apesar dessa possibilidade, hoje em dia temos ótimas IDE (Integrated Development Enviroment) para desenvolvermos na linguagem C. Como exemplo temos: Dev-C++ e Code::Blocks que já vem acompanhados de diversos compiladores, sendo o padrão o GCC.
No Dev-C++, por exemplo, se acessamos o menu Tools/Compiler Options e ativamos a guia programs nos deparamos com os principais compiladores utilizados por ela, e o primeiro que vemos na lista é o GCC: