Atenção
Na linguagem C você deve prestar muita atenção na hora de digitar seu código fonte, pois, o C é caso sensitivo, ou seja, ele diferencia letras maiúsculas de minúsculas. Por exemplo, as palavras história, História e HISTÓRIA são palavras diferentes.
Por exemplo, veja este código abaixo:| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ char Texto[] = "A raiz quadrada de 9 é 3"; printf("%s\n", Texto); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo A raiz quadrada de 9 é 3 ~$ |
As palavras Texto e printfestão corretos, porém, se você alterar o código fonte com letras maiúsculas e minúsculas, causará erros no código fonte. Observe:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ char Texto[] = "A raiz quadrada de 9 é 3"; Printf("%s\n", TEXTO); return 0; } |
| ERRO |
As palavras TEXTO e Printf estão errados, causando erros. O computador não reconhece estas palavras. Na hora em que digitar o código fonte preste bastante atenção nas letras maiúsculas e minúsculas, por causa de uma letra pode causar erros.
Uma boa prática ao programar utilizando c é sempre usar o; (ponto-e-vírgula) no final das suas declarações, mas seu uso é obrigatório.
Você precisa utilizar o ponto-e-vírgula se utilizar algum compressor de C para reduzir o tamanho do arquivo. como os comperssores distribuem os códigos em uma única linha, sem eles será impossível determinar onde começa e termina uma istruçõa, ocasionando erro.
Editor de texto é apenas um processador de texto que é usado para digitar o programa. O texto resultante é conhecido como código fonte.
O editor de texto é um software que permite ao usuário selecionar trechos de um arquivo, alterar, apagar ou adicionar testo ao código-fonte.
Código-fonte é uma seqüência de instruções numa linguagem de programação. O código-fonte é escrito por um programador.
Este mesmo código é traduzido por um outro programador que pode ser pelo navegador no caso do Javascript, pelo servidor no caso do PHP, ou pelo compilador no caso Java.
O código-fonte é o código básico de um programa.
Para começar vamos analisar um exemplo bem simples - abra um editor de texto comum e digite o código que está escrito abaixo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #define CLEAR printf("\033c"); #define clear printf("\e[H\e[2J"); int main(int argc, char **argv){ CLEAR; // limpa a tela printf("Este é meu primeiro programa.\n"); return 0; } |
| Resultado: |
| Este é meu primeiro
programa. ~$ |
Salve este documento com o nome Exemplo.c
Assim que o exemplo for salvo no editor de texto (bloco de notas, por exemplo) com a extensão .c, ao ser executado, o programa enviará a seqüência de caracteres "Esta é minha primeira página" para a saída padrão que é a tela do monitor.
Para criar um arquivo C basta definir os elementos e suas formatações ou um editor de texto, e salvá-lo com a extensão .c, exemplo:
programa.c
texto.c
arquivo01.c
Basicamente, a sintaxe do corpo do programa consiste em:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ // Conteúdo return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo ~$ |
No C. há a possibilidade de colocar mais de 1 arquivo externo ao documento. Ao invés de trabalharmos com o C internamente, podemos trabalhá-lo externamente. Em vez de trabalharmos com um arquivo, podemos trabalhar com mais de um arquivo.
Isto pode facilitar e muito a vida do programador.
Abra um editor de texto e copie o arquivo abaixo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ #include "teste.c" return 0; } |
Para incluir um arquivo externo ao documento use o comando #include no exemplo acima o arquivo externo é teste.c Devemos sempre salvar este arquivo externo com a extensão c.
Abra o editor de texto de novo e copie este arquivo abaixo:
| Arquivo: teste.c |
| printf("Testando um
arquivo
externo. "); printf("Bom dia "); printf("Boa tarde e "); printf("Boa noite. "); printf("Fim do arquivo externo.\n"); |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Testando um arquivo externo. Bom dia Boa tarde e Boa noite. Fim do arquivo externo. ~$ |
Salve este arquivo como teste.c.
Assim que o documento Exemplo.c seja executado ao ser executado o programa enviará para a tela do monitor: "Testando um arquivo externo. Bom dia, Boa tarde e Boa noite. Fim do arquivo externo."
Comentário é uma breve nota de explicação inseridas em um programa para descrever o que ele fará.
Os programadores usam comentários em seus programas para que outros programadores (e ele próprio) entendam o que o programa faz e como funciona.
Os comentários geralmente descrevem o que o programa faz, quem é o seu autor, por que ele foi alterado, e assim por diante. A maioria das linguagens de programação usa uma sintaxe própria para a especificação de comentários, de modo que os comentários sejam ignorados pelo compilador.
Os comentários não são analisados pelo programa.
Os comentários podem ocupar uma ou várias linhas. Veja o exemplo abaixo:
Para inserir um comentário de uma linha basta colocar o símbolo // antes de qualquer comentário.
Exemplo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ //Comentário de uma linha //Exemplo 1 //Exemplo 2 //Exemplo 3 return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo ~$ |
Para inserir comentários com mais de uma linha basta colocar os símbolos / * para abrir um comentário e * / para fechar o comentário.
Exemplo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ /* Comentário com mais de uma linha */ return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo ~$ |
Para inserir um texto no programa use o comando document.write, veja o exemplo abaixo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ printf("A raiz quadrada de 9 é 3\n"); printf("A soma de 5 + 4 é igual a 9\n"); printf("6 dividido por 3 é igual a 2\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo A raiz quadrada de 9 é 3 A soma de 5 + 4 é igual a 9 6 dividido por 3 é igual a 2 ~$ |
Para editar um texto externamente basta usar o comando leia:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char nome[50]; int idade; printf("Digite um texto:"); fgets(nome, 50, stdin); if (nome[strlen(nome)-1]=='\n') nome[strlen(nome)-1]='\0'; printf("Digite sua idade:"); scanf("%d",&idade); printf("meu nome é %s e tenho %d anos.", nome, idade); printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um texto:João Antônio Digite sua idade:26 meu nome é João Antônio e tenho 26 anos. ~$ |
Dentro de uma string de texto, podem ser especificado caracteres especiais mostrados a seguir:
| Hífen | \' |
| Aspas | \" |
| Barra invertida | \\ |
| Nova linha | \n |
| Marca de tabulação | \t |
| Retorno de carro | \r |
| Backspace | \b |
Exemplo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ printf("\tO livro: \"Manual Prático do "); printf("Programador\". \nEstá nas livrarias "); printf("e \\ ou jornaleiros. "); printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo O livro: "Manual Prático do Programador". Está nas livrarias e \ ou jornaleiros. ~$ |
Resultado:
O livro: "Manual Prático do Programador".
Está nas livrarias e \ ou jornaleiros.
Variáveis são símbolos que representa um valor numérico ou string usada no programa. O uso de variáveis dá ao programador flexibilidade para mudar o valor a qualquer momento no programa, mesmo que a princípio pareça não ser necessário este tipo de flexibilidade.
O conteúdo de uma variável pode mudar a qualquer momento.
Por exemplo, uma variável chamado cheque poderia conter o número 12, mas o programa teria condições de modificar esse valor a qualquer momento.
O nome de uma variável pode começar com uma letra ou sublinhado "_" seguido de números ou letras sem espaço. Veja alguns exemplos de nomes válidos:
nome
Conta_pag
z01
_cod
Variável String é um conjunto contínuo de caracteres alfanuméricos que não contém números usados para cálculos. Nomes, endereços, palavras e frases são strings. Esses caracteres podem ser as letras maiúsculas, as letras minúsculas, os números e os caracteres especiais (&, #, @, ?, + ). Exemplos:
"aluno"
"1234"
"@ internet"
"0.34"
"1 + 2"
Observação: os dados do tipo literal na linguagem de programação são sempre representados entre aspas duplas(") ou aspas simples (').
Os dados numéricos dividem-se em dois grupos: inteiros e reais.
Os números inteiros podem ser positivos ou negativos e NÃO possuem parte decimal. Este tipo de dado é armazenado na memória do computador, exemplos:
-23
98
0
1350
-257
237
-2
Os números reais podem ser positivos ou negativos e possuem parte decimal. Este tipo de dado é armazenado na memória do computador, exemplo:
23.45
346.98
-34.88
0.0
-247.0
Observação: na linguagem de programação, a separação entre a parte inteira e a parte decimal de um número é feita pelo ponto (.), e a simples presença do ponto já significa que é um número real.
Variável Booleana é uma expressão cujo resultado só pode ser verdadeiro (true) ou falso (false).
As variáveis booleanas são mais usadas em:
Este tipo de variável, quando armazenado na memória do computador, ocupa 1 byte, pois possui apenas duas possibilidades de representação: true ou false.
Exemplo:
| Expressão | Resultado | Significado |
| teste=true | verdadeiro | |
| x=false | falso | |
| y=true | verdadeiro | |
| a=4<2 | a=false | falso |
| b=8>3 | b=true | verdadeiro |
| c=(3>2)&&(5<4) | c=false | falso |
| d=(3>4)||(5<4) | d=true | verdadeiro |
O primeiro operador que você deve conhecer é o de atribuição "=". Ele atribui o conteúdo da expressão à sua direita para a variável do seu lado esquerdo.
x=30
y=10/2 + 6
z=true
a="texto"
Para criar uma variável, a variável deve obedecer as seguintes regras:
O C por exemplo, faz diferenciação entre letras maiúsculas e minúsculas; portanto a variável NUM é exatamente diferente a variável num;
Observação: algumas linguagens de programação são sensíveis à caixa alta e caixa baixa, um exemplo disso é o Java, "Olá" e "OLÁ" são duas palavras totalmente diferentes. O Delphi por exemplo não é sensível a caixa, "abc" é exatamente igual a "ABC".
Palavras reservadas são nomes utilizados pelo compilador para representar comandos de controle do programa, operadores e nomes de seções de programas. As palavras reservadas da linguagem Pascal são: (veja a tabela abaixo)
Exemplos de variáveis válidos:
A
a
nota
NOTA
x5
A32
Nota_1
MATRICULA
nota_1
dia
IDADE
Exemplos de variáveis inválidos
5b
e 12
x-y
prova 2n
nota(2)
case
Set
matrícula
Obs: matrícula com acento no í.
Resolva os exercícios abaixo:Exercício 1: Identifique o tipo dos dados:
(a) numérico inteiro;
(b) numérico real;
(c) lógico;
(d) string.
| (c) true | (b) 45.0 | (a) 1234 | (b) 0.0 |
| (d) "aula" | (d) "c * d" | (a) -234 | (d) "1 2 3 4" |
| (b) -0.342 | (b) 35.23 | (d) "34" | (b) -18.589 |
| (d) " " | (b) -354.0 | (b) -15.2 | (c) false |
| (a) 0 | (a) 897 | (d) "false" | (a) -23 |
Concatenar: Reunir duas strings de caracteres em um só por exemplo, combinar as duas strings "bom" e "dia" formando uma única string "bom dia".
| Exemplo1: Exemplo.c | Exemplo1: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Variavel[100]; strcpy(Variavel,"Texto1 "); strcat(Variavel,"Texto2 "); strcat(Variavel,"Texto3."); printf("Resultado da variável: %s", Variavel); printf("\n"); return 0; } |
#include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Variavel[100]; sprintf(Variavel, "Texto1 "); sprintf(Variavel, "%sTexto2 ", Variavel); sprintf(Variavel, "%sTexto3.", Variavel); printf("Resultado da variável: %s", Variavel); printf("\n"); return 0; } |
| Resultado: | Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Resultado da variável: Texto1 Texto2 Texto3. ~$ |
~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Resultado da variável: Texto1 Texto2 Texto3. ~$ |
| Exemplo2: Exemplo.c | Exemplo2: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Variavel[100]; strcpy(Variavel,"Isto é "); strcat(Variavel,"um texto"); printf("Resultado da variável: %s", Variavel); printf("\n"); return 0; } |
#include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Variavel[100]; sprintf(Variavel,"Isto é "); sprintf(Variavel,"%sum texto",Variavel); printf("Resultado da variável: %s", Variavel); printf("\n"); return 0; } |
| Resultado: |
Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Resultado da variável: Isto é um texto ~$ |
~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Resultado da variável: Isto é um texto ~$ |
| Exemplo3: Exemplo.c | Exemplo3: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Nome[]="José "; char Sobrenome[]="Antônio"; char Variavel[100]; strcpy (Variavel,Nome); strcat (Variavel,Sobrenome); printf("Meu nome é: %s", Variavel); printf("\n"); return 0; } |
#include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Nome[]="José "; char Sobrenome[]="Antônio"; char Variavel[100]; sprintf(Variavel,"%s%s",Nome, Sobrenome); printf("Meu nome é: %s", Variavel); printf("\n"); return 0; } |
| Resultado: |
Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Meu nome é: José Antônio ~$ |
~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Meu nome é: José Antônio ~$ |
Se não convertermos os valores strings para numéricas impossibilita de efetuarmos cálculos matemáticos, por exemplo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char A[] = "7"; char B[] = "9"; int C = 5; int res = A+B+C; printf("Seu resultado será: %d\n",res); return 0; } |
| ERRO |
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char A[] = "7"; char B[] = "9"; int C = 5; int res = atoi(A)+atoi(B)+C; printf("Seu resultado será: %d\n",res); return 0; } |
| Resultados: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Seu resultado será: 21 ~$ |
Veja outro exemplo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char Altura[100]; char Largura[100]; printf("Digite a Altura: "); scanf("%s",Altura); printf("Digite a Largura: "); scanf("%s",Largura); float Area = (atof(Altura)*atof(Largura))/2; printf("Área: %f\n",Area); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite a Altura: 2.222 Digite a Largura: 432.78 Área: 480.818573 ~$ |
Se efetuarmos os cálculos Area = (Altura*Largura)/2 sem converter string em numérica geraríamos erros de programação.
O correto é Area = (atof(Altura)*atof(Largura))/2.
Exercício 1: Use a calculadora abaixo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char campo1[100]; char campo2[100]; printf("Digite um Número: "); scanf("%s",campo1); printf("Digite outro Número: "); scanf("%s",campo2); printf("Soma = 0\n"); printf("Subtração = 1\n"); printf("Multiplicação = 2\n"); printf("Divisão = 3\n"); char op[100]; printf("Digite um operador: \n"); scanf("%s",op); int opN = atoi(op); float op1 = atof(campo1); float op2 = atof(campo2); float res = 0; if(opN==0){ res = op1+op2; } else if(opN==1){ res = op1-op2; } else if(opN==2){ res = op1*op2; } else if(opN==3){ res = op1/op2; } printf("Resultado: %f\n",res); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um Número: 334 Digite outro Número: 786 Soma = 0 Subtração = 1 Multiplicação = 2 Divisão = 3 Digite um operador: 1 Resultado: -452.000000 ~$ |
Exercício 2: Use esta outra calculadora
| Arquivo: Exemplo.c | Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> float processa1(float op1,float op2,float op3){ return op1+op2+op3; } float processa2(float op1,float op2,float op3){ return op1*op2*op3; } int main(int argc, char **argv){ char campo1[100]; char campo2[100]; char campo3[100]; printf("Digite um número: "); scanf("%s",campo1); printf("Digite outro número: "); scanf("%s",campo2); printf("Digite mais um número: "); scanf("%s",campo3); printf("Soma = 0\n"); printf("Multiplicação = 1\n"); char op[100]; printf("Digite um operador: \n"); scanf("%s",op); int opN = atoi(op); float op1 = atof(campo1); float op2 = atof(campo2); float op3 = atof(campo3); float res = 0; if(opN==0){ res = processa1(op1,op2,op3); } else if(opN==1){ res = processa2(op1,op2,op3); } printf("Resultado: %f\n",res); return 0; } |
#include
<stdio.h> #include <stdlib.h> float processa1(float op1,float op2,float op3); float processa2(float op1,float op2,float op3); int main(int argc, char **argv){ char campo1[100]; char campo2[100]; char campo3[100]; printf("Digite um número: "); scanf("%s",campo1); printf("Digite outro número: "); scanf("%s",campo2); printf("Digite mais um número: "); scanf("%s",campo3); printf("Soma = 0\n"); printf("Multiplicação = 1\n"); char op[100]; printf("Digite um operador: \n"); scanf("%s",op); int opN = atoi(op); float op1 = atof(campo1); float op2 = atof(campo2); float op3 = atof(campo3); float res = 0; if(opN==0){ res = processa1(op1,op2,op3); } else if(opN==1){ res = processa2(op1,op2,op3); } printf("Resultado: %f\n",res); return 0; } float processa1(float op1,float op2,float op3){ return op1+op2+op3; } float processa2(float op1,float op2,float op3){ return op1*op2*op3; } |
| Resultado: |
Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um número: 333 Digite outro número: 333 Digite mais um número: 333 Soma = 0 Multiplicação = 1 Digite um operador: 1 Resultado: 36926036.000000 ~$ |
~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um número: 333 Digite outro número: 333 Digite mais um número: 333 Soma = 0 Multiplicação = 1 Digite um operador: 1 Resultado: 36926036.000000 ~$ |
Operadores são símbolos que representa uma operação matemática; são três tipos de operadores:
O operador mais usado é o operador de atribuição "=". Ele atribui o conteúdo da expressão à sua direita para a variável do seu lado esquerdo.
X=40
X=20/10 + 5
X=Y
Operadores aritméticos são símbolos usados pelo computador + , -, * , /, para efetuar cálculos matemáticos.
Os operadores aritméticos são os seguintes:
| Operadores | Nome | Utilização |
| + | Adição | Soma valores |
| - | Subtração | Subtrai valores |
| * | Multiplicação | Multiplica valores |
| / | Divisão | Divide valores |
| % | Módulo | Determina o resto da divisão |
Veja os exemplos abaixo:
Exemplo 1: Efetue cálculos usando operadores aritméticos
| Operação | Resultado |
| 5 + 8 | 13 |
| 12-7 | 5 |
| 3 * 6 | 18 |
| 10/3 | 3.333333 |
| 10 % 3 | 1 |
Exemplo 2: Efetue cálculos aritméticos usando parênteses
| Operação | Resultado |
| 4 * 2 + 1 | 9 |
| 4 * (2 + 1) | 12 |
| 3 + 5 * 4-2 | 21 |
| (3 + 5) * (4-2) | 16 |
| + | Adição |
| - | Subtração |
| * | Multiplicação |
| / | Divisão |
| ( ) | Parênteses |
Lista de Exercícios:
Exercício 1. Faça um programa que receba quatro números inteiros, calcula e mostre a soma desses números
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char n1[100]; char n2[100]; char n3[100]; printf("Digite um número: "); scanf("%s",n1); printf("Digite outro número: "); scanf("%s",n2); printf("Digite mais um número: "); scanf("%s",n3); float op1 = atof(n1); float op2 = atof(n2); float op3 = atof(n3); float res = op1+op2+op3; printf("Resultado da Soma: %f\n",res); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um número: 848 Digite outro número: 858 Digite mais um número: 985 Resultado da Soma: 2691.000000 ~$ |
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char base[100]; char altura[100]; printf("Base: "); scanf("%s",base); printf("Altura: "); scanf("%s",altura); float b = atof(base); float h = atof(altura); float res = (b * h)/2; printf("Resultado da área: %f\n",res); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Base: 100 Altura: 200 Resultado da área: 10000.000000 ~$ |
Exercício 4. Faça um programa que receba o salário de um funcionário, calcule e mostre o novo salário, sabendo-se que este sofreu um aumento de 25%.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char salario[100]; printf("Salário: "); scanf("%s",salario); float sal = atof(salario); float aumento = sal * 25 / 100; float novosal = sal + aumento; printf("Novo Salário: %f\n",novosal); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Salário: 880 Novo Salário: 1100.000000 ~$ |
Exercício 5. Crie um programa que dê o
resultado da
soma, do produto e da diferença.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ printf("Entre com dois números:\n"); char A[100]; char B[100]; printf("A: "); scanf("%s",A); printf("B: "); scanf("%s",B); float opA = atof(A); float opB = atof(B); printf("Operações com números %s e %s:\n",A,B); printf("Soma = %f\n",(opA+opB)); printf("Produto = %f\n",(opA*opB)); printf("Diferença = %f\n",(opA-opB)); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Entre com dois números: A: 32 B: 47 Operações com números 32 e 47: Soma = 79.000000 Produto = 1504.000000 Diferença = -15.000000 ~$ |
Exercício 6. Crie um programa que dê o quadrado de um número
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char n[100]; printf("Digite um número: "); scanf("%s",n); float opN = atof(n); float Quadrado = opN * opN; printf("O quadrado de %s é %f\n",n,Quadrado); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um número: 4 O quadrado de 4 é 16.000000 ~$ |
Operadores relacionais são operadores que permitem ao programador comparar dois (ou mais) valores ou expressões.
Os operadores relacionais típicos são: (veja a tabela abaixo:)
| Operador | Significado | Exemplo |
| == | Igual | 3==(4-1) |
| != | Diferente | 5 != (3 + 3) |
| < | Menor que | 3<23 |
| > | Maior que | 41>39 |
| <= | Menor ou igual a | 5 <= 6 |
| >= | Maior ou igual a | 10 >= 10 |
Veja os exemplos abaixo:
Exemplo 1. Veja o seguinte resultado
| Operação | Resultado |
| 23<3 | false (falso) |
| 41>39 | true (verdadeiro) |
| 6 <= 5 | false (falso) |
| 10 >= 10 | true (verdadeiro) |
| 7==8 | false (falso) |
| 48 != 22 | true (verdadeiro) |
Exemplo 2. Se a=100 e b=200, calcule:
| Operação | Resultado |
| a>b | false (falso) |
| b>a | true (verdadeiro) |
| a != b | true (verdadeiro) |
Exemplo 3. Resolva a seguinte operação:
| Operação | Resultado |
| 23==(4 * 2 + 3 * 5) | true (verdadeiro) |
| 17==(12/2 + 8-5) | false (falso |
|
23==(4 * 2 + 3 * 5) 23==(8 + 15) 23==23 true |
17==(12/2 + 8-5) 17==6 + 8-5 17==9 false |
Exemplo 4. Dadas as strings abaixo resolva:
| Operação | Resultado |
| strcmp("FRED","FRED")==0 | true (verdadeiro) |
| strcmp("FRED","SAM")!=0 | true (verdadeiro) |
| strcmp("ONE","TWO")==0 | false (falso) |
| strcmp("THREE","THREE")!=0 | false (falso) |
AND, OR, XOR e NOT são as operações fundamentais a lógica booleana.
Estes operadores só aceitam como operandos valores lógicos: TRUE ou FALSE.
Veja a tabela abaixo
| Operador | Significado |
| And ( && ) | Verdadeiro se ambos os lados da expressão forem verdadeiros. |
| Or ( || ) | Verdadeiro se um ou ambos os lados da expressão forem verdadeiros |
| Xor ( ^ ) | Verdadeiro se apenas um lado for verdadeiro |
| Not ( ! ) | Reverte verdadeiro para falso e vice-versa |
Se você está acostumado com o C, C++ , Java e Javascript já deve ter notado que seus operadores booleanos usam símbolos diferentes.
And é substituído por &&
Or é substituído por ||
e Not é substituído por !
Se o leitor não teve nenhum contato com essas linguagens, poderá ter algumas dificuldades iniciais de escrever este tipo de código. Por exemplo:
(x>2)&&(y==9)
Leia-se: x maior que 2 E y igual a 9
(x<3)||(x>8)
Leia-se: x menor que 3 OU x maior que 8
if((altura>170)||(idade>18)) {
// Ação...
}
Leia-se: se altura maior que 170 centímetros OU idade maior que 18 anos...
Veja a tabela abaixo:
| Símbolo | Operação |
| && | And (E) |
| || | Or (Ou) |
| ! | Not (Não) |
Existem os operadores binários (semelhantes aos operadores acima), veja a tabela abaixo:
| Símbolo | Operação |
| & | And lógico |
| | | Or lógico |
| ^ | Xor lógico |
Iremos estudar cada um:
AND (&&) é verdadeiro se ambas as entradas forem verdadeiras, veja o quadro abaixo:
| (a==true)&&(b==true) o resultado é true (verdadeiro) |
| (a==false)&&(b==true) o resultado é false (falso) |
| (a==true)&&(b==false) o resultado é false (falso) |
| (a==false)&&(b==false) o resultado é false (falso) |
Por exemplo a expressão:
(3 + 2==5)&&(6 + 2==8)
É verdadeira porque as expressões em ambos os lados de And são verdadeiras. no entanto, a expressão:
(4 + 3==9)&&(3 + 3==6)
É falsa, porque a expressão à esquerda de And é falsa. Lembre-se disto quando combinar expressões com And: se qualquer expressão for falsa, toda a expressão será falsa.
OR (||) é verdadeiro se qualquer uma das entradas for verdadeira, veja o quadro abaixo:
| (a==true)||(b==true) o resultado é true (verdadeiro) |
|
(a==false)||(b==true) o resultado é true (verdadeiro) |
| (a==true)||(b==false) o resultado é true (verdadeiro) |
| (a==false)||(b==false) o resultado é false (falso) |
Por exemplo, as expressões:
(3 + 6==2)||(4 + 4==8)
e
(4 + 1==5)||(7 + 2==9)
São ambas verdadeiras porque pelo menos uma das expressões comparada é verdadeira. Observe que no segundo caso, ambas as expressões comparadas são verdadeiras, o que também torna verdadeira uma expressão Or.
Um XOR (OU exclusivo) é verdadeiro se somente uma das entradas for verdadeira e não ambas, veja o quadro abaixo:
| (a==true)^(b==true) o resultado é false (falso) |
| (a==false)^(b==true) o resultado é true (verdadeiro) |
| (a==true)^(b==false) o resultado é true (verdadeiro) |
| (a==false)^(b==false) o resultado é false (falso) |
Por exemplo, a expressão:
(3 + 6==2)^(4 + 4==8)
É verdadeira porque apenas a expressão (4 + 4=8) é verdadeira. No entanto a expressão:
(4 + 1==5)^(7 + 2==9)
É falsa, porque ambas as expressões são verdadeiras.
NOT (!) Uma operação lógica booleana que inverte a entrada. Se a entrada for true, a saída é false, e vice-versa, veja o quadro abaixo:
| !(true) o resultado é false |
| !(false) o resultado é true |
Por exemplo, a expressão:
(4 + 3==5)
Não é verdadeira; no entanto a expressão
!(4 + 3==5)
É verdadeira porque o operador Not reverte para verdadeiro o resultado falso da expressão (4 + 3=5).
Observe esta expressão:
(4 + 5==9) && !(3 + 1==3)Esta expressão é verdadeira ou falsa? Se você disse verdadeira, compreende a forma como funcionam os operadores lógicos. As expressões em ambos os lados de And são verdadeiras, então toda a expressão é verdadeira.
Veja exemplos abaixo:
Exemplo 1. Resulta as seguintes operações booleanas
| Expressão | Resultado |
| (3>2)&&(5>4) | true (verdadeiro) |
| (2>1)&&(7>8) | false (falso) |
| (3>4)||(9>2) | true (verdadeiro) |
| (7>7)||(4>4) | false (falso) |
| (2==2)^(5==5) | false (falso) |
| (4>5)^(4<5) | true (verdadeiro) |
| ! true | false (falso) |
| ! (9<1)||(9<1) | true (verdadeiro) |
Exemplo 2. Se a=100, b=200 e c=300, resolva:
| Expressão | Resultado |
| b>a && c>b | true (verdadeiro) |
| b>a && b==c | falso (falso) |
| b>a || b==c | true (verdadeiro) |
| b>a ^ c>b | false (falso) |
| ! a <> b | false (falso) |
Exemplo 3. Resolva a seguinte operação:
Solução
(4 * (3 + 5))/2>100 || (5 * (3 + 4)/2<100)
(4 * 8)/2>100 || (5 * 7/2<100)
32/2>100 || (35/2<100)
16>100 || 17.5<100
false || false
false
Observe a lista de prioridades abaixo:
Resumindo
| Nível de prioridade | Operadores | Ordem | |
| Mais alta: | 1 | Variáveis | da esquerda para a direita |
| 2 | Propriedades do Objeto | da esquerda para a direita | |
| 3 | Parênteses | da esquerda para a direita | |
| 4 | Funções | da esquerda para a direita | |
| 5 | Potenciação | da esquerda para a direita | |
| 6 | * , /, % | da esquerda para a direita | |
| 7 | + , - | da esquerda para a direita | |
| 8 | >, <, >= , <= , ==, != | da esquerda para a direita | |
| 9 | ! | da esquerda para a direita | |
| Mais baixa: | 10 | &&, || | da esquerda para a direita |
O comando If é uma instrução de linguagem de programação que compara dois ou mais conjuntos de dados e verifica os resultados. Se o resultado for verdadeiro, as instruções que seguem o comando If serão executados; se não, as instruções que seguirem o comando Else serão executados. Veja o exemplo abaixo:
Vejamos:
| Arquivo: Exercicio.c |
| #include
<stdio.h> typedef enum {false=0, true=1} boolean; int main(int argc, char **argv){ boolean A=true; if(A==true){ printf("Execute B\n"); } else { printf("Execute C\n"); } return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Execute B ~$ |
Outro exemplo a seguir também é um exemplo bem simples:
| Arquivo: Exemplo.c |
| #include
<stdio.h> typedef enum {false=0, true=1} boolean; int main(int argc, char **argv){ boolean teste=true; if(teste){ printf("Esta linha será impressa\n"); } else { printf("Esta linha não será impressa\n"); } return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Esta linha será impressa ~$ |
Vamos ver um exemplo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int Desconto = 315; if(Desconto!=0){ printf("Desconto deste mês: %d", Desconto); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Desconto deste mês: 315 ~$ |
O sistema só executará o comando printf quando o valor da variável desconto for maior que 0. Agora, ficou claro que este comando é muito útil para dar ao sistema uma espécie de "poder de decisão". na verdade, estamos programando o sistema para cada tipo de situação e então o software agirá conforme a necessidade de cada problema, situação ou estado do sistema naquele momento.
Podemos dar ao fluxo mais uma opção utilizando a cláusula else. Nesse caso, o fluxo executará o bloco antes ou depois desta cláusula. No exemplo anterior, podemos incrementar o código com mais uma situação.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int Desconto = 315; if(Desconto!=0){ printf("Desconto deste mês: %d", Desconto); } else { printf("Não há descontos este mês."); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Desconto deste mês: 315 ~$ |
Para entender melhor o exemplo troque o valor da variável Descontos para zero e teste novamente.
A cláusulaelse if nos permite ter várias expressões dentro do mesmo comando If. Isso permite escolher entre várias situações e, caso nenhuma retorne verdadeiro, o fluxo irá para a cláusula else, se esta for utilizada. Veja
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int Salario=1550; if(Salario<1250){ printf("Remuneração isenta de imposto"); } else if (Salario >= 1250 && Salario<1800) { printf("Retenção de 5%% para imposto mensal"); } else if (Salario >= 1800 && Salario<2200) { printf("Retenção de 7%% para imposto mensal"); } else { printf("Retenção de 9%% para imposto mensal"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Retenção de 5% para imposto mensal ~$ |
Podemos observar que a cláusula else if pode ser utilizada várias vezes, permitindo calcular várias faixas para um valor de salário. Aqui, utilizamos a variável Salario, mas este valor pode vir de um banco de dados que será alimentado por usuários do sistema, em momento totalmente distinto a sua programação.
Por isso, os sistemas são bastante flexíveis aos dados e devem tratá-los de acordo com as normas e legislações vigentes.
Podemos verificar isso no exemplo anterior, no qual para cada faixa salarial é aplicado um imposto que, em um software oficial, deve estar de acordo com as normas legais.
Lista de exercícios
Exercício 1. Elaborar um algoritmo para receber um número inteiro e informar se ele é par ou ímpar.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int num = 0; printf("Número: "); scanf("%d",&num); if(num % 2 == 0){ printf("Par"); } else { printf("Impar"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Número: 22 Par ~$ |
Exercício 2. Receber a temperatura - em graus Celsius - de uma pessoa e emitir uma mensagem se ela estiver com febre.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int temperatura = 0; int febre = 37; printf("Temperatura: "); scanf("%d",&temperatura); if(temperatura >= febre){ printf("Paciente com febre"); } else { printf("Paciente sem febre"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Temperatura: 32 Paciente sem febre ~$ |
Exercício 3. Crie um algoritmo que informa se você é do sexo masculino ou feminino
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char s_n[10]; printf("Você é do sexo masculino? s/n? "); scanf("%s",s_n); // if(s_n[0]=='s') { // ou if(strcmp(s_n,"s")==0){ printf("Você é do sexo masculino\n"); }else{ printf("Você é do sexo feminino\n"); } return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Você é do sexo masculino? s/n? s Você é do sexo masculino ~$ |
Exercício 4. Faça um programa que indique se o ano é bissexto ou não.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int Ano = 0; printf("Digite o ano: "); scanf("%d",&Ano); if(Ano % 4 == 0) { printf("%d é bissexto",Ano); } else { printf("%d não é bissexto",Ano); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite o ano: 2014 2014 não é bissexto ~$ |
| < | Menor que |
| > | Maior que |
| == | Igual a |
| <= | Menor ou Igual a |
| >= | Maior ou igual a |
| != | Diferente |
Lista de exercícios
Exercício 1. Faça um programa que indique se ele é maior, menor ou igual a 100.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int numero = 0; printf("Numero: "); scanf("%d",&numero); if(numero < 100){ printf("O número é menor do que 100"); } else { printf("O número é maior ou igual a 100"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Numero: 30 O número é menor do que 100 ~$ |
Exercício 2. Faça um programa que indique se ele é positivo, negativo ou igual a 0.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int n = 0; printf("Numero: "); scanf("%d",&n); if(n>0){ printf("O número é positivo"); } else { printf("O número ou é igual a 0 ou é negativo"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Numero: 30 O número é menor do que 100 ~$ |
Exercício 3. Faça um programa que receba dois números e mostre o maior.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int num1 = 0; int num2 = 0; printf("Digite o primeiro número: "); scanf("%d",&num1); printf("Digite o segundo número: "); scanf("%d",&num2); if(num1>num2){ printf("O maior número é: %d", num1); } else if(num1<num2){ printf("O maior número é: %d", num2); } else if(num1==num2){ printf("Os números são iguais"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite o primeiro número: 44 Digite o segundo número: 55 O maior número é: 55 ~$ |
Exercício 4. Criar um algoritmo que receba a idade e informe se é criança, adolescente, adulto ou idoso:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int idade = 0; printf("Qual a sua idade? "); scanf("%d",&idade); if(idade<13){ printf("Você é uma criança"); } else if(idade<18){ printf("Você é um adolescente"); } else if(idade<65){ printf("Você é um adulto"); } else { printf("Você é um idoso"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Qual a sua idade? 36 Você é um adulto ~$ |
| AND | && | (E) |
| OR | || | (OU) |
| NOT | ! | (NÃO) |
Lista de exercícios
Exercício 1. Faça um programa que receba três notas de um aluno, calcule e mostre a média aritmética e diga se foi aprovado, reprovado ou em recuperação.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char nota1[100]; char nota2[100]; char nota3[100]; printf("Digite a primeira nota: "); scanf("%s",nota1); printf("Digite a segunda nota: "); scanf("%s",nota2); printf("Digite a terceira nota: "); scanf("%s",nota3); float opNota1 = atof(nota1); float opNota2 = atof(nota2); float opNota3 = atof(nota3); float media = (opNota1+opNota2+opNota3)/3; printf("Média aritmética: %f\n",media); if(media>=0 && media<5){ printf("Reprovado"); }else if(media>=5 && media<7){ printf("Em recuperação"); }else if(media>=7 && media<=10){ printf("Aprovado"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite a primeira nota: 7 Digite a segunda nota: 7 Digite a terceira nota: 7 Média aritmética: 7.000000 Aprovado ~$ |
Exercício 2. Faça um programa que receba três notas de um aluno, calcule e mostre a média aritmética e diga se tirou nota A, B, C, D, ou E.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char nota1[100]; char nota2[100]; char nota3[100]; printf("Digite a primeira nota: "); scanf("%s",nota1); printf("Digite a segunda nota: "); scanf("%s",nota2); printf("Digite a terceira nota: "); scanf("%s",nota3); float opNota1 = atof(nota1); float opNota2 = atof(nota2); float opNota3 = atof(nota3); float media = (opNota1+opNota2+opNota3)/3; printf("Média aritmética: %f\n",media); if(media>=8 && media<=10){ printf("nota A"); }else if(media>=6 && media<8){ printf("nota B"); }else if(media>=4 && media<6){ printf("nota C"); }else if(media>=2 && media<4){ printf("nota D"); }else if(media>=0 && media<2){ printf("nota E"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite a primeira nota: 8 Digite a segunda nota: 7 Digite a terceira nota: 6 Média aritmética: 7.000000 nota B ~$ |
Exercício 3. Dados três valores A, B, C, verificar se eles formam um triângulo eqüilátero, isósceles ou escaleno.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char A_[100]; char B_[100]; char C_[100]; printf("Triângulo\n"); printf("Lado A: "); scanf("%s",A_); printf("Lado B: "); scanf("%s",B_); printf("Lado C: "); scanf("%s",C_); float A = atof(A_); float B = atof(B_); float C = atof(C_); if(A<(B + C) && B<(A + C) && C<(A + B)) { if(A==B && B==C) { printf("Triângulo Eqüilátero"); } else if(A==B || A==C || B==C) { printf("Triângulo Isósceles"); } else { printf("Triângulo Escaleno"); } }else { printf("Estes valore não formam um triângulo"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Triângulo Lado A: 30 Lado B: 30 Lado C: 30 Triângulo Eqüilátero ~$ |
Exercício 4. Crie uma estrutura de decisão comparando dois alunos e informe se ele foram aprovados ou reprovados
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Aluno1[] = "Aprovado"; char Aluno2[] = "Reprovado"; if(strcmp(Aluno1, "Aprovado")==0 && strcmp(Aluno2, "Aprovado")==0){ printf("Ambos estão aprovados!\n"); } else { printf("Um dos alunos foi reprovado.\n"); } return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Um dos alunos foi reprovado. ~$ |
Repare nesta outra construção para comando if aninhado:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ int mes = 2; if (mes==1) {printf("Jan");} else if (mes==2) {printf("Fev");} else if (mes==3) {printf("Mar");} else if (mes==4) {printf("Abr");} else if (mes==5) {printf("Mai");} else if (mes==6) {printf("Jun");} else if (mes==7) {printf("Jul");} else if (mes==8) {printf("Ago");} else if (mes==9) {printf("Set");} else if (mes==10) {printf("Out");} else if (mes==11) {printf("Nov");} else if (mes==12) {printf("Dez");} else {printf("Mês inválido");} printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Fev ~$ |
Embora essa construção seja perfeitamente válida, há uma forma mais eficiente de se obter os mesmos resultados. É o comando case cujo funcionamento é muito parecido com os if's aninhados:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ int mes = 2; switch (mes){ case 1: printf("Jan"); break; case 2: printf("Fev"); break; case 3: printf("Mar"); break; case 4: printf("Abr"); break; case 5: printf("Mai"); break; case 6: printf("Jun"); break; case 7: printf("Jul"); break; case 8: printf("Ago"); break; case 9: printf("Set"); break; case 10: printf("Out"); break; case 11: printf("Nov"); break; case 12: printf("Dez"); break; default: printf("Mês inválido!"); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Fev ~$ |
Este comando permite que várias comparações sejam feitas e, no final, apenas uma seja escolhida para executar um código específico da condição selecionada. Ele funciona igualmente a vários ifs, mas agora ele testa os valores de uma mesma variável.
Vejamos um exemplo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int valor = 2; switch (valor){ case 0: printf("O valor da variável é 0"); break; case 1: printf("O valor da variável é 1 "); break; case 2: printf("O valor da variável é 2 "); break; case 3: printf("O valor da variável é 3 "); break; case 4: printf("O valor da variável é 4 "); break; } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo O valor da variável é 2 ~$ |
No exemplo anterior, o comando Case testará linha a linha, em busca de um case que corresponda ao valor da variável.
Quando encontrar o valor correspondente, executará os comandos que virão logo após este case.
Em linguagens de programação tais como o C, Java, Javascript PHP, esses comandos estarão entre { }, se for mais que um. Teste o código e veja como fica.
Quando precisamos executar apenas o case que corresponda ao valor da variável, utilizaremos um comando que tem a característica de para fluxos de execução, o comando break. Caso esse não seja utilizado, todos os cases após o case que corresponda ao valor da variável de referência serão executados.
Utilizando o exemplo anterior, veremos como ficaria o código com o uso do comando break:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int valor = 2; switch (valor){ case 0: printf("O valor da variável é 0"); break; case 1: printf("O valor da variável é 1 "); break; case 2: printf("O valor da variável é 2 "); break; case 3: printf("O valor da variável é 3 "); break; case 4: printf("O valor da variável é 4 "); break; } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo O valor da variável é 2 ~$ |
No exemplo anterior, apenas os comandos que correspondam ao case que tem o mesmo valor da variável serão executados.
Teste os exemplos anteriores, veja a diferença entre eles e descobrirá que o exemplo que possui o break é, nesse caso, o correto.
Exemplo 1. Determine o número de dias durante um mês
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int Mes = 0; int Ano = 0; printf("Digite o mês: "); scanf("%d",&Mes); printf("Digite o ano: "); scanf("%d",&Ano); int NumDias = 0; switch(Mes){ case 4: case 6: case 9: case 11: NumDias = 30; break; case 2: if(Ano % 4 == 0){ NumDias = 29; } else { NumDias = 28; } break; default: NumDias=31; break; } printf("O mês %d tem %d dias",Mes,NumDias); printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite o mês: 2 Digite o ano: 2004 O mês 2 tem 29 dias ~$ |
Exemplo 2. Crie um algoritmo que informe o dia da semana
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <time.h> int main(int argc, char **argv){ struct tm *local; time_t t; t= time('\0'); local=localtime(&t); int dia=local->tm_mday; int mes=local->tm_mon; int ano=local->tm_year+1900; int dia_da_semana=local->tm_wday; switch(dia_da_semana) { case 0: printf("Domingo"); break; case 1: printf("Segunda"); break; case 2: printf("Terça"); break; case 3: printf("Quarta"); break; case 4: printf("Quinta"); break; case 5: printf("Sexta"); break; case 6: printf("Sábado"); break; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Terça ~$ |
Exemplo 3: Crie um algoritmo que dê um aviso de bom dia, boa tarde e boa noite:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <time.h> int main(int argc, char **argv){ struct tm *local; time_t t; t= time('\0'); local=localtime(&t); int horas=local->tm_hour; int minutos=local->tm_min; int segundos=local->tm_sec; switch(horas){ case 6: case 7: case 8: case 9: case 10: case 11: printf("Bom dia!"); break; case 12: case 13: case 14: case 15: case 16: case 17: printf("Boa tarde!"); break; default: printf("Boa noite!"); break; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Bom dia! ~$ |
Exemplo 4. Crie um programa que gerencie um caixa eletrônico
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ printf("1 - Inclusão\n"); printf("2 - Alteração\n"); printf("3 - Exclusão\n"); printf("4 - Relatório\n"); printf("5 - Fim\n"); int menu = 0; printf("Escolha sua opção: "); scanf("%d",&menu); switch(menu){ case 1: printf("Incluir");break; case 2: printf("Alterar");break; case 3: printf("Excluir");break; case 4: printf("Relatório");break; case 5: printf("Sair");break; default: printf("Opção inválida");break; } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1 - Inclusão 2 - Alteração 3 - Exclusão 4 - Relatório 5 - Fim Escolha sua opção: 4 Relatório ~$ |
Exercício 5. Crie uma calculadora com as 4 operações da matemática: adição, subtração, divisão e multiplicação.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> int main(int argc, char **argv){ char A_[100]; printf("Digite o primeiro número: "); scanf("%s",A_); char B_[100]; printf("Digite o segundo número: "); scanf("%s",B_); char operador[10]; printf("Escolha um operador +, -, *, / "); scanf("%s",operador); float A = atof(A_); float B = atof(B_); switch(operador[0]){ case '+': printf("Resultado da soma %f\n",(A+B)); break; case '-': printf("Resultado da subtração %f\n",(A-B)); break; case '*': printf("Resultado da Multiplicação %f\n",(A*B)); break; case '/': printf("Resultado da divisão %f\n",(A/B)); break; default: printf("Caractere diferente de +, -, *, /\n"); break; } return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite o primeiro número: 7 Digite o segundo número: 7 Escolha um operador +, -, *, / * Resultado da Multiplicação 49.000000 ~$ |
Exercício 6. Crie um programa que digite um caractere e diga se ele é vogal maiúscula, valor numérico, operador aritmético ou outro caractere.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ char caractere[10]; printf("Escolha um caractere: "); scanf("%s",caractere); switch(caractere[0]){ case 'A': case 'E': case 'I': case 'O': case 'U': printf("Vogal maiúscula"); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': printf("Valor numérico"); break; case '+': case '-': case '*': case '/': printf("Operador aritmético"); break; default: printf("Você digitou outro caractere"); break; } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Escolha um caractere: A Vogal maiúscula ~$ |
Diferente da instrução IF, o operador ternário tem este nome porque necessita de três operandos para se avaliado. O operador ternário tem a seguinte forma:
condição1 ? expressão_verdadeira : espressão_falsa
Para avaliar o resultado da expressão primeiro a condição1 é avaliada. Caso este resultado seja verdadeiro então resultado da expressão será igual ao valor da expressão_verdadeira, no caso contrário expressão_falsa é avaliada e se torna o resultado.
Exemplo 1:| Arquivo: Exemplo.c | Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ int variavel=50; char resultado[100]; strcpy(resultado, (variavel >= 0)&&(variavel <= 100) ? "VERDADEIRO" : "FALSO"); printf("%s\n", resultado); return 0; } |
#include
<stdio.h> #include <string.h> int main(int argc, char **argv){ int variavel=50; char resultado[100]; sprintf(resultado,"%s", (variavel >= 0)&&(variavel <= 100) ? "VERDADEIRO" : "FALSO"); printf("%s\n", resultado); return 0; } |
| Resultado: | Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo VERDADEIRO ~$ |
~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo VERDADEIRO ~$ |
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int horas = 30; int minutos = 45; int segundos = 30; horas = (horas>=0)&&(horas<=24) ? horas : 0; minutos = (minutos>=0)&&(minutos<=60) ? minutos : 0; segundos = (segundos>=0)&&(segundos<=60) ? segundos : 0; printf("São %d:%d:%d\n", horas, minutos, segundos); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo São 0:45:30 ~$ |
Exemplo 3:
| Arquivo: Exemplo.c | Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char **argv){ char nota1[100]; char nota2[100]; char nota3[100]; printf("Digite a primeira nota: "); scanf("%s",nota1); printf("Digite a segunda nota: "); scanf("%s",nota2); printf("Digite a terceira nota: "); scanf("%s",nota3); float opNota1 = atof(nota1); float opNota2 = atof(nota2); float opNota3 = atof(nota3); float media = (opNota1+opNota2+opNota3)/3; printf("Média aritmética: %f\n",media); char resultado[100]; strcpy(resultado,(media>=6)&&(media<=10) ? "Aprovado" : "Reprovado"); printf("%s\n",resultado); return 0; } |
#include
<stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char **argv){ char nota1[100]; char nota2[100]; char nota3[100]; printf("Digite a primeira nota: "); scanf("%s",nota1); printf("Digite a segunda nota: "); scanf("%s",nota2); printf("Digite a terceira nota: "); scanf("%s",nota3); float opNota1 = atof(nota1); float opNota2 = atof(nota2); float opNota3 = atof(nota3); float media = (opNota1+opNota2+opNota3)/3; printf("Média aritmética: %f\n",media); char resultado[100]; sprintf(resultado, "%s", (media>=6)&&(media<=10) ? "Aprovado" : "Reprovado"); printf("%s\n",resultado); return 0; } |
| Resultado: |
Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite a primeira nota: 10 Digite a segunda nota: 10 Digite a terceira nota: 10 Média aritmética: 10.000000 Aprovado ~$ |
~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite a primeira nota: 10 Digite a segunda nota: 10 Digite a terceira nota: 10 Média aritmética: 10.000000 Aprovado ~$ |
O comando FOR é uma estrutura de repetição que repete uma série de instruções um número especificado de vezes. Digamos que deseje imprimir seu nome na tela dez vezes, por exemplo:
| Arquivo: Exemplo.c |
| /* Lendo strings
com espaço em
branco e acentos usando fgets */ #include <stdio.h> #include <string.h> int main(int argc, char **argv){ char nome[200]; printf("Digite um nome: "); fgets(nome, 50, stdin); if(nome[strlen(nome)-1]=='\n') nome[strlen(nome)-1]='\0'; printf("%s\n",nome); printf("%s\n",nome); printf("%s\n",nome); printf("%s\n",nome); printf("%s\n",nome); printf("%s\n",nome); printf("%s\n",nome); printf("%s\n",nome); printf("%s\n",nome); printf("%s\n",nome); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um nome: Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons ~$ |
Bart Simpson
Bart Simpson
Bart Simpson
Bart Simpson
Bart Simpson
Bart Simpson
Bart Simpson
Bart Simpson
Bart Simpson
Bart Simpson
Ter muitas linhas em seu programa contendo instruções idênticas alonga-o além do necessário e desperdiça memória. Também mostra um estilo de programação ruim. Ao menos que você deseje que seus amigos programadores riam de você pelas costas, aprenda a substituir códigos de programa redundante por loops de programa.
A rotina do programa anterior pode ser extremamente fácil usando-se um loop For, e aqui está como:
| Arquivo: Exemplo.c |
| /* Lendo strings
com espaço em
branco e acentos com o fgets*/ #include <stdio.h> #include <string.h> int main(int argc, char **argv){ char nome[200]; printf("Digite um nome: "); fgets(nome, 50, stdin); if(nome[strlen(nome)-1]=='\n') nome[strlen(nome)-1]='\0'; int i; for(i=1;i<=10;i++){ printf("%s\n",nome); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um nome: Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons Bart Simpsons ~$ |
Substitua a rotina do programa anterior por esta. Quando você roda o programa, a saída será idêntica àquela do primeiro programa, mas agora o programa é menor e sem código redundante.
Exercício 1. Crie uma estrutura de repetição que conte de 1 até 10.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=1;x<=10;x++){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ~$ |
Exercício 2. Crie uma estrutura de repetição que imprima os números pares.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=0; x<=20; x=x+2){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, ~$ |
Resultado: 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20,
Exercício 3. Crie uma estrutura de repetição que imprima os números ímpares.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=1; x<=21; x=x+2){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, ~$ |
Resultado: 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21,
Exercício 4. Crie uma estrutura de repetição que imprima os números múltiplos de 5.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=0; x<=50; x=x+5){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, ~$ |
Resultado: 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50,
Exercício 5. Crie uma estrutura de repetição que conte de 110 até 120.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=110; x<=120; x++){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, ~$ |
Resultado: 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
Exercício 6. Crie uma estrutura de repetição que conte de 40 até 80 e ao mesmo tempo imprima números múltiplos de 8.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=40; x<=80; x+=8){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 40, 48, 56, 64, 72, 80, ~$ |
Resultado: 40, 48, 56, 64, 72, 80,
Exercício 7. Crie uma estrutura de repetição que conte de 20 até 1 invertidamente.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=20; x>=1; x--){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ~$ |
Resultado: 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
Exercício 8. Crie uma estrutura de repetição que conte de -10 até + 10 (números negativos e números positivos)
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=-10; x<=10; x++){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ~$ |
Resultado: -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
Exercício 9. Crie uma estrutura de repetição que conte de -25 até -15.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=-25; x<=-15; x++){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo -25, -24, -23, -22, -21, -20, -19, -18, -17, -16, -15, ~$ |
Resultado: -25, -24, -23, -22, -21, -20, -19, -18, -17, -16, -15,
Exercício 10. Crie um conjunto dos números múltiplos de 3 usando a estrutura de repetição FOR.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=0; x<=30; x+=3){ printf("%d, ",x); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, ~$ |
Exercício 11. Crie uma estrutura de repetição de 1 até 10, informando o quadrado deste número.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int N = 0; int Quadrado = 0; for (N=1; N<=10; N++){ Quadrado=N * N; printf("O quadrado de %d é %d\n",N,Quadrado); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo O quadrado de 1 é 1 O quadrado de 2 é 4 O quadrado de 3 é 9 O quadrado de 4 é 16 O quadrado de 5 é 25 O quadrado de 6 é 36 O quadrado de 7 é 49 O quadrado de 8 é 64 O quadrado de 9 é 81 O quadrado de 10 é 100 ~$ |
Exercício 12. Crie uma estrutura de repetição que imprima "Olá" dez vezes.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x; for(x=1; x<=10; x++){ printf("Olá\n"); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Olá Olá Olá Olá Olá Olá Olá Olá Olá Olá ~$ |
O comando while é utilizado quando se deseja repetir um comando, ou um grupo de comandos, enquanto uma dada condição for verdadeira. Um exemplo muito simples é o de escrever os números inteiros entre 1 e 10 na tela. Para isto podemos construir um programa muito simples para esta tarefa
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int i=1; while(i <= 10) { printf("%d, ",i); i=i+1; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ~$ |
Segundo o programa acima podemos ver que o programa termina quando o teste i <= 10 der como resultado false.
Para que isto ocorra, necessariamente devemos ter i>10. A cada passo o programa primeiro testa a condição e após imprime e incrementa a variável. Assim o programa deve gerar seqüencialmente os valores 1, 2, 3... 10. Após o valor 10 faz i=11 e volta a testar a condição. Neste caso (11 <= 10) é false e o programa termina.
Exercício 1. Crie uma estrutura de repetição que conte de 1 até 10.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=1; while(x <= 10) { printf("%d, ",x); x=x+1; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ~$ |
Resultado: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
Exercício 2. Crie uma estrutura de repetição que imprima os números pares
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=0; while(x <= 20){ printf("%d, ",x); x=x+2; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, ~$ |
Resultado: 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20,
Exercício 3. Crie uma estrutura de repetição que imprima os números ímpares.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=1; while(x < 21) { printf("%d, ",x); x=x+2; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, ~$ |
Resultado: 1, 3, 5, 7, 9, 11, 13, 15, 17, 19,
Exercício 4. Crie uma estrutura de repetição que imprima os números múltiplos de 5.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=0; while(x <= 50){ printf("%d, ",x); x=x+5; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, ~$ |
Exercício 5. Crie uma estrutura de repetição que conte de 110 até 120.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=110; while(x <= 120){ printf("%d, ",x); x=x+1; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, ~$ |
Resultado: 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
Exercício 6. Crie uma estrutura de repetição que conte de 40 até 80 e ao mesmo tempo imprima números múltiplos de 8.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=40; while(x <= 80) { printf("%d, ",x); x=x+8; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 40, 48, 56, 64, 72, 80, ~$ |
Resultado: 40, 48, 56, 64, 72, 80,
Exercício 7. Crie uma estrutura de repetição que conte de 20 até 1 invertidamente.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=20; while(x >= 1) { printf("%d, ",x); x=x-1; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ~$ |
Resultado: 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
Exercício 8. Crie uma estrutura de repetição que conte de -10 até + 10 (números negativos e números positivos)
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=-10; while(x <= 10) { printf("%d, ",x); x=x+1; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ~$ |
Resultado: -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
Exercício 9. Crie uma estrutura de repetição que conte de -25 até -15.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=-25; while(x <= -15) { printf("%d, ",x); x=x+1; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo -25, -24, -23, -22, -21, -20, -19, -18, -17, -16, -15, ~$ |
Exercício 10. Crie um conjunto dos números múltiplos de 3 usando a estrutura de repetição while.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=0; while(x <= 30) { printf("%d, ",x); x=x+3; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, ~$ |
Resultado: 0, 3, 6, 12, 15, 18, 21, 24, 27, 30,
Assim como a instrução For e a instrução while, vistos anteriormente, o loop invertido, ao contrário do comando while, é um bloco de comando que será executado pelo menos uma vez e será repetido até que a condição associada seja verdadeira.
Há situações em que é importante se garantir a execução de uma seqüência de comandos pelo menos uma vez. Veja um exemplo simples:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int mes = 0; printf("Digite o mês: "); scanf("%d",&mes); while(mes<1 || mes>12){ printf("Digite o mês: "); scanf("%d",&mes); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite o mês: 22 Digite o mês: 44 Digite o mês: 12 ~$ |
Podemos simplificar este comando somente uma vez, usando a estrutura de repetição do while.
do while é o loop invertido de while.
Usando o exemplo anterior iremos substituir o comando while pelo comando do , observe:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int mes = 0; do{ printf("Digite o mês: "); scanf("%d",&mes); if(mes<1 || mes>12){ printf("Digitação errada! Digite de novo\n"); } }while(mes<1 || mes>12); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite o mês: 44 Digitação errada! Digite de novo Digite o mês: 33 Digitação errada! Digite de novo Digite o mês: 12 ~$ |
Naturalmente, é necessário uma variável do tipo caractere que receba a resposta do usuário e que será utilizada para controlar a estrutura de repetição. Teríamos algo como:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Resp[10]; do{ /* Sequência de comandos do programa propriamente dito */ printf("Deseja continuar (s/n)? "); scanf("%s",Resp); }while(strcmp(Resp,"n")!=0); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Deseja continuar (s/n)? s Deseja continuar (s/n)? s Deseja continuar (s/n)? s Deseja continuar (s/n)? s Deseja continuar (s/n)? n ~$ |
Observe mais um exemplo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ char Resp[10]; int num = 0; do{ printf("Digite um número: "); scanf("%d",&num); if(num<100){ printf("O número %d é menor do que 100\n",num); } printf("Deseja continuar (s/n)? "); scanf("%s",Resp); }while(strcmp(Resp,"n")!=0); return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Digite um número: 10000 Deseja continuar (s/n)? s Digite um número: 10 O número 10 é menor do que 100 Deseja continuar (s/n)? n ~$ |
Veja o exemplo abaixo:
Atenção, não teste este código!Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int Contador = 0; int n = 0; while(Contador<=10){ printf("%d, ",n); n = n + 1; } return 0; } |
Se você entendeu os exemplos anteriores sobre os loops, deve perceber que existe um erro nesse exemplo. Como pode ver a condição do loop while refere-se à variável contador, mas essa variável realmente não se altera durante o loop. Isso crua um loop infinito. O loop continuará executando até que seja interrompido pelo usuário ou até gerar algum tipo de erro.
Os loops infinitos nem sempre podem ser interrompidos pelo usuário, exceto fechando o seu terninal em alguns casos os loops infinitos podem até impedir que o seu terminal feche ou provocar uma pane no sistema.
Eles também podem ser difíceis de serem identificados, porque este tipo de código não lhe mostrará um erro dizendo que há um loop infinito. Mas não se preocupe, pois esse tipo de loop pode ser evitado, o que tem que fazer é: toda vez que for criar um loop em um script, você deve ter cuidado de certificar-se de que há uma saída.
Nota: Dependendo da versão do navegador em utilização, o loop infinito pode até mesmo fazer o navegador para de responder ao usuário. Certifique-se de fornecer uma rota de escape de loops infinitos e salvar seu script até testá-lo, em qualquer eventualidade.
Ocasionalmente, você pode querer criar um loop infinito. Isso talvez inclua situações em que você quer que seu programa execute até o usuário interrompê-lo ou em que fornece uma rota de escape com a instrução break. Uma maneira de criar um loop infinito é o seguinte:
while(true) { ...}
Como o valor true é condicional, esse loop sempre encontrará sua condição como sendo verdadeira.
Há uma maneira de escapar de um loop infinito. Você pode utilizar a instrução break (que significa parar) durante um loop para sair dele imediatamente e continuar a primeira instrução depois do loop. O exemplo abaixo mostra o uso dessa instrução.
| Arquivo: Exemplo.c |
| #include
<stdio.h> typedef enum {false=0, true=1} boolean; int main(int argc, char **argv){ int n=0; int total=0; while(true){ n=n+1; total=total+n; printf("%d, ",total); if(total>=100){ break; } } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105, ~$ |
Embora a instrução while esteja configurada como um loop infinito, a instrução if verifica o valor correspondente. Se total maior que 100, sai do loop.
Quando este tipo de código encontra uma instrução break, ele pula o resto do loop e continua o script com a primeira instrução depois da chave de fechamento no final do loop. Você pode utiliza a instrução breakem qualquer tipo de loop, seja infinita ou não.
O comando Break interrompe o comando while ou For que está sendo executado e transfere o controle do programa para o comando seguinte aquele que encerra o loop.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int i=0; while(i<20){ i=i+1; if(i==10) break; printf("%d, ",i); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1, 2, 3, 4, 5, 6, 7, 8, 9, ~$ |
A declaração continue é usada quando não se quer executar nenhum dos comandos daquele ponto até o fim do bloco, mas queremos que o laço prossiga com a próxima interação. No caso do exemplo anterior, se i for 10, o laço se interrompe e o restante da matriz não será preenchido. Em lugar disto, podemos usar continue que não só salta o processo de atualização, mas salta além do calcula que iria provocar um erro. O seguinte código permite que o laço continue, mas salta todos os números ímpares.
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int k=0; while(k <= 20){ k++; if((k%2)!=0) continue; printf("%d, ",k); } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, ~$ |
Resultado: 2, 4, 6, 8, 10, 12, 14, 16, 18, 20,
Existem dois tipos de operadores incrementais o incremento (x++ ) e o decremento (x--)
O incremento (x++ ) aumenta o valor da variável em uma unidade, o decremento (x--) diminui o valor da variável em uma unidade, ou seja:
x++ é idêntico a x=x + 1
x-- é idêntico a x=x-1
Os operadores de incremento e decremento podem ser prefixos ou pós-fixos - isto é, podem ser colocados antes ( ++x) ou depois (x++); da mesma forma é o decremento (--x) igual a (x--), ou seja:
x++ é semelhante a ++x e
x-- é semelhante a --x.
Conclui-se da seguinte forma:
x++ ou ++x é idêntico a x=x + 1
x-- ou --x é idêntico a x=x-1
Veja o exemplo abaixo:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int a = 0; a = 2; printf("Se a=2\n"); a++; printf("O resultado de a++ é %d\n",a); a = 2; printf("Se a=2\n"); ++a; printf("O resultado de ++a é %d\n",a); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Se a=2 O resultado de a++ é 3 Se a=2 O resultado de ++a é 3 ~$ |
O resultado da execução deste pequeno script é o seguinte:
Se a=2
O resultado de a++ é 3
Se a=2
O resultado de ++a é 3
Da mesma forma são os operadores decrementais a-- e --a, é só substituir + + por --; porém o resultado é 1.
Os operadores incrementais são muito usados em estruturas de repetições, tais como o For e o while. Exemplo:
Exemplo 1:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=1; while(x<=10){ printf("%d, ",x); x++; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ~$ |
Resultado: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
Exemplo 2:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int x=20; while(x >= 1){ printf("%d, ",x); --x; } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ~$ |
Resultado: 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
Atenção programadores!!!
Em linguagens de programação tais como Java e o Javascript devemos ter cuidado na hora de usar operadores incrementais.
Quando colocamos uma variável e um outro operador de atribuição "=" na frente dos operadores incrementais + + e -- há uma sutil diferença:
A=x++
é diferente de
A= ++x
Imagine que variável x seja igual a 5. Nos dois casos o resultado de A deveria ser 6 nas duas operações.
| a=2 a=a++ Resultado de: a=2 |
a=2 a=++a Resultado de: a=3 |
| a=2 a=a-- Resultado de: a=2 |
a=2 a=--a Resultado de: a=1 |
Veja o exemplo na prática:
| Arquivo: Exemplo.c |
| #include
<stdio.h> int main(int argc, char **argv){ int a = 0; a = 2; printf("Incrementos\n"); printf("a=2\n"); printf("a++=%d\n\n",a++); a = 2; printf("a=2\n"); printf("++a=%d\n\n",++a); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Incrementos a=2 a++=2 a=2 ++a=3 ~$ |
O resultado da execução deste pequeno script é o seguinte:
a=2
a++=2
++a=3
| Arquivo: Exemplo.c |
| #include <stdio.h> int main(int argc, char **argv){ int a = 0; a = 2; printf("Decrementos\n"); printf("a=2\n"); printf("a--=%d\n\n",a--); a = 2; printf("a=2\n"); printf("--a=%d\n\n",--a); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Decrementos a=2 a--=2 a=2 --a=1 ~$ |
Operadores de atribuição (semelhante aos operadores aritméticos) são símbolos usados pelo computador + , -, * , /, para efetuar cálculos matemáticos.
Veja tabela abaixo:
| Nome | Operador | Utilização | Equivalente a |
| Adição | += | a+=b | a=a + b |
| Subtração | -= | a-=b | a=a-b |
| Multiplicação | * = | a * =b | a=a * b |
| Divisão | /= | a/=b | a=a/b |
| Módulo | %= | a%=b | a=a%b |
| Concatenação | += | a+=b | a=a+b |
Veja os exemplos:
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(int argc, char **argv){ // Exemplo 1: int a=2; int b=3; a+=b; // Resultado a=5, idêntico a a=a + b printf("%d\n",a); // Exemplo 2: int x=7; int y=4; x-=y; // Resultado x=3, idêntico a x=x-y printf("%d\n",x); // Exemplo 3: int V1=8; V1*=2; // Resultado V1=16, idêntico a V1=V1 * 2 printf("%d\n",V1); // Exemplo 4: int z=12; z/=3; // Resultado z=4, idêntico a z=z/3 printf("%d\n",z); // Exemplo 5: int h=9; int i=2; h%=i; // Resultado h=1, idêntico a h=h%i // Observação: O operador Módulo retorna o resto da divisão printf("%d\n",h); // Exemplo 6: char Variavel[100]; strcpy(Variavel,"texto 1 "); strcat(Variavel,"texto 2"); // Resultado variavel="texto 1 texto 2" idêntico a variavel="texto 1 "+"texto 2" printf("%s\n",Variavel); printf("\n"); return 0; } |
#include
<stdio.h> #include <string.h> int main(int argc, char **argv){ // Exemplo 1: int a=2; int b=3; a+=b; // Resultado a=5, idêntico a a=a + b printf("%d\n",a); // Exemplo 2: int x=7; int y=4; x-=y; // Resultado x=3, idêntico a x=x-y printf("%d\n",x); // Exemplo 3: int V1=8; V1*=2; // Resultado V1=16, idêntico a V1=V1 * 2 printf("%d\n",V1); // Exemplo 4: int z=12; z/=3; // Resultado z=4, idêntico a z=z/3 printf("%d\n",z); // Exemplo 5: int h=9; int i=2; h%=i; // Resultado h=1, idêntico a h=h%i // Observação: O operador Módulo retorna o resto da divisão printf("%d\n",h); // Exemplo 6: char Variavel[100]; sprintf(Variavel,"%s %s", "texto 1", "texto 2"); // Resultado variavel="texto 1 texto 2" idêntico a variavel="texto 1 "+"texto 2" printf("%s\n",Variavel); printf("\n"); return 0; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 5 3 16 4 1 texto 1 texto 2 ~$ |
~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 5 3 16 4 1 texto 1 texto 2 ~$ |
Array é um conjunto de dados semelhantes (Como números, letras ou strings) armazenados com o mesmo nome. Aos dados é atribuído um número diferente no array.
Quando o array tem somente uma dimensão, é chamado de vetor.
A maioria das linguagens de programação pode armazenar e manipular matrizes de uma ou mais dimensões. As matrizes multidimensionais são muito usados em simulação científica e no processamento matemático; entretanto uma matriz pode ser apenas uma tabela de preços mantidas na memória para acesso instantâneo por um programa de entrada de pedido.
Os arrays se dividem em dois grupos: vetores e matrizes.
Vetores são arrays com uma dimensão.
Matrizes são arrays com mais de uma dimensão.
1 - Na horizontal
| Arquivo: Exemplo.c |
| char sexo[][100] =
{"masculino",
"feminino"}; int numero[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; char vogais[][1] = {'A', 'E', 'I', 'O', 'U'}; char Frutas[][100] = {"Banana", "Laranja", "Maçã", "Mamão"}; char Cursos[][100] = {"Português", "Matemática", "Física", "Química", "Biologia", "Inglês", "Geografia", "História"}; char estadocivil[][100] = {"solteiro", "casado", "divorciado", "viúvo"}; |
2 - Na vertical
| Arquivo: Exemplo.c |
| char sexo[][100] = { "masculino", "feminino" }; int numero[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; char vogais[][1] = { 'A', 'E', 'I', 'O', 'U' }; char Frutas[][100] = { "Banana", "Laranja", "Maçã", "Mamão" }; char Cursos[][100] = { "Português", "Matemática", "Física", "Química", "Biologia", "Inglês", "Geografia", "História" }; char estadocivil[][100] = { "solteiro", "casado", "divorciado", "viúvo" }; |
| Arquivo: Exemplo.c |
| #include
<stdio.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ char Cursos[][100] = {"Português", "Matemática", "Física", "Química", "Biologia", "Inglês", "Geografia", "História"}; int x; int n = NUM_ELEM(Cursos); for(x = 0; x<n; x++){ printf("%s\n",Cursos[x]); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Português Matemática Física Química Biologia Inglês Geografia História ~$ |
| Arquivo: Exemplo.c |
| #include
<stdio.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ char vogais[][1] = {'A', 'E', 'I', 'O', 'U'}; int x; int n = NUM_ELEM(vogais); for(x = 0; x<n; x++){ printf("%c\n",vogais[x][0]); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo A E I O U ~$ |
| Arquivo: Exemplo.c |
| #include
<stdio.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ int numero[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; int x; int n = NUM_ELEM(numero); for(x = 0; x<n; x++){ printf("%d\n",numero[x]); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo 1 2 3 4 5 6 7 8 9 ~$ |
Exercício 1. Elabore um vetor vertical que contenha os dias da semana.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ char lista[][100] = { "Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sábado", "Domingo" }; int x; int n = NUM_ELEM(lista); for(x = 0; x<n; x++){ printf("%s\n",lista[x]); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Segunda Terça Quarta Quinta Sexta Sábado Domingo ~$ |
Exercício 2. Elabore um vetor horizontal que contenha os meses do ano.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ char mes[][100] = {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"}; int x; int n = NUM_ELEM(mes); for(x = 0; x<n; x++){ printf("%s\n",mes[x]); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Janeiro Fevereiro Março Abril Maio Junho Julho Agosto Setembro Outubro Novembro Dezembro ~$ |
Exercício 3. A partir da tabela abaixo, foram criados dois vetores de 6 posições: NOME e IDADE.
| Nome | Idade | |
| 1 | Beatriz | 19 |
| 2 | Pedro | 32 |
| 3 | Cláudio | 23 |
| 4 | Susana | 27 |
| 5 | Marcos | 16 |
| 6 | Celina | 35 |
Com base nesta informação, diga o que será impresso pelas instruções abaixo:
|
int x; int n = NUM_ELEM(Nome); for(x = 0; x<n; x++){ if(idade[x]<20){ printf("%s\n",Nome[x]); } } |
Solução:
| Arquivo: Exemplo.c |
#include < stdio.h > |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Beatriz Marcos ~$ |
Exercício 4. A tabela abaixo contém o nome de algumas ruas e o bairro onde se localizam.
| Rua | Bairro |
| Mena Barreto | Botafogo |
| Constança Barbosa | Méier |
| Marechal Câmara | Centro |
| Álvaro Ramos | Botafogo |
| Cesário Alvim | Humaitá |
| José Clemente | Niterói |
As instruções a seguir iniciam um programa que cria os vetores RUAS e BAIRROS. Escreva um programa de forma que ele imprima o nome das ruas do bairro de Botafogo.
Solução
| Arquivo: Exemplo.c |
|
#include <stdio.h> #include <stdlib.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ char ruas[][100] = {"Mena Barreto", "Constança Barbosa", "Marechal Câmara", "Álvaro Ramos", "Cesário Alvim", "José Clemente"}; char bairros[][100] = {"Botafogo", "Méier", "Centro", "Botafogo", "Humaitá", "Niterói"}; int x; int n = NUM_ELEM(bairros); printf("Número total de bairros: %d\n",n); for(x = 0; x<n; x++){ printf("Rua: %s, bairro: %s\n",ruas[x],bairros[x]); } printf("\nRuas do bairro de Botafogo:\n"); for(x=0; x<n; x++){ if(strcmp(bairros[x],"Botafogo")==0){ printf("Nome da rua: %s. Nome do Bairro: %s.\n",ruas[x],bairros[x]); } } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o
Exemplo ~$ ./Exemplo Número total de bairros: 6 Rua: Mena Barreto, bairro: Botafogo Rua: Constança Barbosa, bairro: Méier Rua: Marechal Câmara, bairro: Centro Rua: Álvaro Ramos, bairro: Botafogo Rua: Cesário Alvim, bairro: Humaitá Rua: José Clemente, bairro: Niterói Ruas do bairro de Botafogo: Nome da rua: Mena Barreto. Nome do Bairro: Botafogo. Nome da rua: Álvaro Ramos. Nome do Bairro: Botafogo. ~$ |
Exercício 5. Faça um programa para imprimir o signo do zodíaco correspondente a uma data qualquer (dia / mês).
A tabela a seguir mostra o último dia de cada mês e o signo correspondente:
| Mes | Último dia | Signo |
| 01 | 20 | Capricórnio |
| 02 | 19 | Aquário |
| 03 | 20 | Peixes |
| 04 | 20 | Áries |
| 05 | 20 | Touro |
| 06 | 20 | Gêmeos |
| 07 | 21 | Câncer |
| 08 | 22 | Leão |
| 09 | 22 | Virgem |
| 10 | 22 | Libra |
| 11 | 21 | Escorpião |
| 12 | 21 | Sagitário |
Importante: Armazene o horóscopo em uma array.
| Arquivo: Exemplo.c |
#include < stdio.h > #define NUM_ELEM(x)(sizeof(x) / sizeof( * (x))) int main(int argc, char * * argv) { char signo[][100] = { "Capricórnio", "Aquário", "Peixes", "Áries", "Touro", "Gêmeos", "Câncer", "Leão", "Virgem", "Libra", "Escorpião", "Sagitário" }; int mes[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; int dia[] = { 20, 19, 20, 20, 20, 20, 21, 22, 22, 22, 21, 21 }; int x; int n = NUM_ELEM(signo); printf("Tabela de signos\n\n"); for (x = 0; x < n; x++) { printf("%s ultimo dia %d/%d\n", signo[x], dia[x], mes[x]); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Tabela de signos Capricórnio ultimo dia 20/1 Aquário ultimo dia 19/2 Peixes ultimo dia 20/3 Áries ultimo dia 20/4 Touro ultimo dia 20/5 Gêmeos ultimo dia 20/6 Câncer ultimo dia 21/7 Leão ultimo dia 22/8 Virgem ultimo dia 22/9 Libra ultimo dia 22/10 Escorpião ultimo dia 21/11 Sagitário ultimo dia 21/12 ~$ |
Exercício 6. Faça um programa que imprima na tela a seguinte tabela abaixo:
|
Índice
|
Planeta
|
Luas
|
Anos
|
Distância
|
|
1
|
Mercúrio
|
0
|
0.024
|
58
|
|
2
|
Vênus
|
0
|
0.625
|
108
|
|
3
|
Terra
|
1
|
1
|
150
|
|
4
|
Marte
|
2
|
1.91
|
228
|
|
5
|
Júpiter
|
16
|
12
|
778
|
|
6
|
Saturno
|
18
|
29.9
|
1427
|
|
7
|
Urano
|
15
|
85.24
|
2869
|
|
8
|
Netuno
|
8
|
167.19
|
4498
|
|
9
|
Plutão
|
1
|
251.29
|
5900
|
| Arquivo: Exemplo.c |
#include < stdio.h > #define NUM_ELEM(x)(sizeof(x) / sizeof( * (x))) int main(int argc, char * * argv) { char planeta[][100] = { "Mercúrio", "Vênus", "Terra", "Marte" }; int luas[] = { 0, 0, 1, 2 }; float anos[] = { 0.24, 0.625, 1, 1.91 }; int distancia[] = { 58, 108, 150, 228 }; int x; int n = NUM_ELEM(planeta); printf("Planetas luas anos distância\n"); for (x = 0; x < n; x++) { printf("%s %d %f %d\n", planeta[x], luas[x], anos[x], distancia[x]); } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Planetas luas anos distância Mercúrio 0 0.240000 58 Vênus 0 0.625000 108 Terra 1 1.000000 150 Marte 2 1.910000 228 ~$ |
Tente pensar no problema como uma tabela
| Notas | Nota 1 | Nota 2 | Nota 3 |
| Aluno01 | |||
| Aluno02 | |||
| Aluno03 | |||
| Aluno04 | |||
| Aluno05 |
Veja que esta tabela tem dois tipos de informação: Alunos e notas.
Por exemplo a 2ª nota do aluno 3, encontra-se no cruzamento entre a terceira linha com a segunda coluna, ou melhor, encontra-se no cruzamento entre a linha de índice 2 com a coluna de índice 1 , isto partindo do pressuposto que o índice da primeira linha é 0 e o índice da primeira coluna é também 0 .
Podemos transformar qualquer tabela em matriz.
A array multidimensional mostrado acima pode ser alocado de forma dinâmica. Veja a tabela abaixo:
| Coluna 1 | Coluna 2 | Coluna 3 | |
| Linha 1 |
a[0][0]
|
a[0][1]
|
a[0][2]
|
| Linha 2 |
a[1][0]
|
a[1][1]
|
a[1][2]
|
| Linha 3 |
a[2][0]
|
a[2][1]
|
a[2][2]
|
| Linha 4 |
a[3][0]
|
a[3][1]
|
a[3][2]
|
Existem 4 formas de transformar uma tabela em matriz, veja o exemplo:
Cada aluno tem a sua nota, veja a tabela abaixo:
| Notas | Nota 1 | Nota 2 |
| Aluno01 |
7
|
7.5
|
| Aluno02 |
6
|
5.5
|
| Aluno03 |
7
|
8
|
| Aluno04 |
3
|
7.5
|
| Aluno05 |
4
|
4.5
|
Existem várias formas de transformar tabelas em matrizes. Vejamos o exemplo 01:
No 1º exemplo vamos transformar uma matriz de duas colunas em 2 vetores, veja:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ float Nota1[5]={7, 6, 7, 3, 4}; float Nota2[5] ={7.5, 5.5, 8, 7.5, 4.5}; /* O exemplo acima não é uma matriz, mas sim, dois vetores vistos na lição anterior. Podemos substituir matrizes por vetores. Do exemplo 2 em diante, os vetores são substituídos por matrizes. */ // Para saber quanto o aluno 04 tirou na 2ª nota é fácil: printf("%f\n",Nota2[4-1]); // Observe que o aluno 04 é 3 (4-1) porque as notas iniciam com 0 e não com 1 return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 7.500000 ~$ |
Do exemplo 2 em diante transformamos a tabela em matriz.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ float Classe[5][2] = { {7, 7.5}, {6, 5.5}, {7, 8}, {3, 7.5}, {4, 4.5} }; int x, y; for(y=0; y<=4; y++){ for(x=0; x<=1; x++){ printf("%f\n", Classe[y][x]); } } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 7.000000 7.500000 6.000000 5.500000 7.000000 8.000000 3.000000 7.500000 4.000000 4.500000 ~$ |
Lista de exercício:
Exercício 1. A partir da tabela abaixo, foram criados dois vetores de 6 posições: NOME e IDADE.
| Nome | Idade | |
| 1 | Beatriz | 19 |
| 2 | Pedro | 32 |
| 3 | Cláudio | 23 |
| 4 | Susana | 27 |
| 5 | Marcos | 16 |
| 6 | Celina | 35 |
Com base nesta informação, diga o que será impresso pelas instruções abaixo:
|
int i; int n =NUM_ELEM(Matriz); for(i=0; i<n; i++) { if (atoi(Matriz[i][idade])<20){ printf("%s ", Matriz[i][nome]); } } |
Solução 1:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ int nome = 0; int idade = 1; char Matriz[6][2][100] = { {"Beatriz", "19"}, {"Pedro", "32"}, {"Cláudio", "23"}, {"Susana", "27"}, {"Marcos", "16"}, {"Celina", "35"} }; int i; int n =NUM_ELEM(Matriz); for(i=0; i<n; i++) { if (atoi(Matriz[i][idade])<20){ printf("%s ", Matriz[i][nome]); } } printf("\n"); return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Beatriz Marcos ~$ |
Exercício 2. A tabela abaixo contém o nome de algumas ruas e o bairro onde se localizam.
| Rua | Bairro |
| Mena Barreto | Botafogo |
| Constança Barbosa | Méier |
| Marechal Câmara | Centro |
| Álvaro Ramos | Botafogo |
| Cesário Alvim | Humaitá |
| José Clemente | Niterói |
As instruções a seguir iniciam um programa que cria os vetores RUAS e BAIRROS. Escreva um programa de forma que ele imprima o nome das ruas do bairro de Botafogo.
Solução
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ char Criamatriz[6][2][100]= { {"Mena Barreto", "Botafogo"}, {"Constança Barbosa", "Méier"}, {"Marechal Câmara", "Centro"}, {"Álvaro Ramos", "Botafogo"}, {"Cesário Alvim", "Humaitá"}, {"José Clemente", "Niterói"} }; int i; int n = NUM_ELEM(Criamatriz); for(i=0; i<n; i++){ printf("Rua: %s, bairro: %s\n", Criamatriz[i][0], Criamatriz[i][1]); } printf("\nRuas do bairro de Botafogo\n\n"); for(i=0; i<n; i++){ if(strcmp(Criamatriz[i][1],"Botafogo")==0) { printf("Nome da Rua: %s",Criamatriz[i][0]); printf(" Nome do bairro: %s\n",Criamatriz[i][1]); } } return 0; } |
| Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Rua: Mena Barreto, bairro: Botafogo Rua: Constança Barbosa, bairro: Méier Rua: Marechal Câmara, bairro: Centro Rua: Álvaro Ramos, bairro: Botafogo Rua: Cesário Alvim, bairro: Humaitá Rua: José Clemente, bairro: Niterói Ruas do bairro de Botafogo Nome da Rua: Mena Barreto Nome do bairro: Botafogo Nome da Rua: Álvaro Ramos Nome do bairro: Botafogo ~$ |
Exercício 5. Faça um programa para imprimir o signo do zodíaco correspondente a uma data qualquer (dia / mês).
A tabela a seguir mostra o último dia de cada mês e o signo correspondente:
| Mes | Último dia | Signo |
| 01 | 20 | Capricórnio |
| 02 | 19 | Aquário |
| 03 | 20 | Peixes |
| 04 | 20 | Áries |
| 05 | 20 | Touro |
| 06 | 20 | Gêmeos |
| 07 | 21 | Câncer |
| 08 | 22 | Leão |
| 09 | 22 | Virgem |
| 10 | 22 | Libra |
| 11 | 21 | Escorpião |
| 12 | 21 | Sagitário |
Importante: Armazene o horóscopo em uma array.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ // {mes, dia, signo} char SuperArray[12][3][100]= { {"1", "20", "Capricórnio"}, {"2", "19", "Aquário"}, {"3", "20", "Peixes"}, {"4", "20", "Áries"}, {"5", "20", "Touro"}, {"6", "20", "Gêmeos"}, {"7", "21", "Câncer"}, {"8", "22", "Leão"}, {"9", "22", "Virgem"}, {"10", "22", "Libra"}, {"11", "21", "Escorpião"}, {"12", "21", "Sagitário"} }; int mes=0; int dia=1; int signos=2; printf("Tabela de signos\n\n"); int x; for(x=0; x<=11; x++) { printf( "%s último dia %s/%s\n", SuperArray[x][signos], SuperArray[x][dia], SuperArray[x][mes]); } return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Tabela de signos Capricórnio último dia 20/1 Aquário último dia 19/2 Peixes último dia 20/3 Áries último dia 20/4 Touro último dia 20/5 Gêmeos último dia 20/6 Câncer último dia 21/7 Leão último dia 22/8 Virgem último dia 22/9 Libra último dia 22/10 Escorpião último dia 21/11 Sagitário último dia 21/12 ~$ |
Exercício 6. Faça um programa que imprima na tela a seguinte tabela abaixo:
|
Índice
|
Planeta
|
Luas
|
Anos
|
Distância
|
|
1
|
Mercúrio
|
0
|
0.024
|
58
|
|
2
|
Vênus
|
0
|
0.625
|
108
|
|
3
|
Terra
|
1
|
1
|
150
|
|
4
|
Marte
|
2
|
1.91
|
228
|
|
5
|
Júpiter
|
16
|
12
|
778
|
|
6
|
Saturno
|
18
|
29.9
|
1427
|
|
7
|
Urano
|
15
|
85.24
|
2869
|
|
8
|
Netuno
|
8
|
167.19
|
4498
|
|
9
|
Plutão
|
1
|
251.29
|
5900
|
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> #define NUM_ELEM(x) (sizeof(x)/sizeof( *(x))) int main(int argc, char **argv){ int Planeta=0; int luas=1; int anos=2; int distancia=3; char Matriz[4][4][100]= { {"Mercúrio", "0", "0.24","58"}, {"Vênus", "0", "0.625", "108"}, {"Terra", "1", "1", "150"}, {"Marte", "2", "1.91", "228"} }; printf("Planeta luas anos distância\n\n"); int indice; for(indice=0; indice<=3; indice++){ printf("%s %s %s %s\n", Matriz[indice][Planeta], Matriz[indice][luas], Matriz[indice][anos], Matriz[indice][distancia]); } return 0; } |
| Resultado: |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Planeta luas anos distância Mercúrio 0 0.24 58 Vênus 0 0.625 108 Terra 1 1 150 Marte 2 1.91 228 ~$ |
Função é um subprograma de linguagem de computador que faz alguns cálculos e retorna um único valor para o programa principal.
Exemplo:
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> float Calcule(float a, float b, float c){ float d = a*b/c; return d; } int main(int argc, char **argv){ printf("%f\n",Calcule(4,3,2)); // Resultado 6 return 0; } |
#include
<stdio.h> float Calcule(float a, float b, float c); int main(int argc, char **argv){ printf("%f\n",Calcule(4,3,2)); // Resultado 6 return 0; } float Calcule(float a, float b, float c){ float d = a*b/c; return d; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 6.000000 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 6.000000 ~$ |
O comando return é uma instrução que encerra o processamento de uma função e transfere o controle de volta ao módulo que o chamou, e (opcionalmente) especifica o valor da função.
A função acima retornou o valor que é 6.
Uma função pode retornar ou não poder retornar valores, basta não usar a instrução return.
Exemplo:
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> void Calcule(float a, float b, float c){ printf("%f\n",a*b/c); } int main(int argc, char **argv){ Calcule(4,3,2); // Resultado 6 return 0; } |
#include
<stdio.h> void Calcule(float a, float b, float c); int main(int argc, char **argv){ Calcule(4,3,2); // Resultado 6 return 0; } void Calcule(float a, float b, float c){ printf("%f\n",a*b/c); } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 6.000000 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 6.000000 ~$ |
O exemplo acima a função não retornou valores.
Em um único programa pode ser armazenado várias funções diferentes, por exemplo:
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> // Funções float Adicao(float a, float b){ float c=a + b; return c; } float Subtracao(float a,float b) { return a-b; } float Multiplicacao(float a,float b){ float c=a*b; return c; } float Divisao(float a,float b){ return a/b; } int main(int argc, char **argv){ // Programa principal printf("2 + 8=%f\n",Adicao(2, 8)); printf("7-3=%f\n",Subtracao(7, 3)); printf("3 * 4=%f\n",Multiplicacao(3,4)); printf("8/2=%f\n",Divisao(8, 2)); return 0; } |
#include
<stdio.h> // Funções float Adicao(float a, float b); float Subtracao(float a,float b); float Multiplicacao(float a,float b); float Divisao(float a,float b); int main(int argc, char **argv){ // Programa principal printf("2 + 8=%f\n",Adicao(2, 8)); printf("7-3=%f\n",Subtracao(7, 3)); printf("3 * 4=%f\n",Multiplicacao(3,4)); printf("8/2=%f\n",Divisao(8, 2)); return 0; } float Adicao(float a, float b){ float c=a + b; return c; } float Subtracao(float a,float b) { return a-b; } float Multiplicacao(float a,float b){ float c=a*b; return c; } float Divisao(float a,float b){ return a/b; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 2 + 8=10.000000 7-3=4.000000 3 * 4=12.000000 8/2=4.000000 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 2 + 8=10.000000 7-3=4.000000 3 * 4=12.000000 8/2=4.000000 ~$ |
Lista de exercícios
Exercício 1. Crie uma função que calcule a soma de dois números
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> float soma(float x, float y){ float sum=x+y; return sum; } int main(int argc, char **argv){ printf("A soma de 5 e 4 é %f\n",soma(5, 4)); return 0; } |
#include
<stdio.h> float soma(float x, float y); int main(int argc, char **argv){ printf("A soma de 5 e 4 é %f\n",soma(5, 4)); return 0; } float soma(float x, float y){ float sum=x+y; return sum; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo A soma de 5 e 4 é 9.000000 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo A soma de 5 e 4 é 9.000000 ~$ |
Exercício 2. Crie uma função que calcule o cubo de um número.
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> int cubo(int x){ int cubo=x*x*x; return cubo; } int main(int argc, char **argv){ printf("O cubo de 8 é igual a %d\n",cubo(8)); return 0; } |
#include
<stdio.h> int cubo(int x); int main(int argc, char **argv){ printf("O cubo de 8 é igual a %d\n",cubo(8)); return 0; } int cubo(int x){ int cubo=x*x*x; return cubo; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo O cubo de 8 é igual a 512 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo O cubo de 8 é igual a 512 ~$ |
Exercício 3. Crie uma função que calcule a área do retângulo
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> float calcArea(float largura, float altura){ float a = largura * altura; return a; } int main(int argc, char **argv){ float largura = 4; float altura = 8; printf("%f\n",calcArea(largura,altura)); return 0; } |
#include
<stdio.h> float calcArea(float largura, float altura); int main(int argc, char **argv){ float largura = 4; float altura = 8; printf("%f\n",calcArea(largura,altura)); return 0; } float calcArea(float largura, float altura){ float a = largura * altura; return a; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 32.000000 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 32.000000 ~$ |
Exercício 4. Crie uma função que calcule números fatoriais
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> int fatorial(int num){ int res = 1; int k = 0; for(k=num;k>=1;k--){ res=res*k; } return res; } int main(int argc, char **argv){ int k = 1; for(k=1;k<=10;k++){ printf("%d! = %d\n",k,fatorial(k)); } return 0; } |
#include
<stdio.h> int fatorial(int num); int main(int argc, char **argv){ int k = 1; for(k=1;k<=10;k++){ printf("%d! = %d\n",k,fatorial(k)); } return 0; } int fatorial(int num){ int res = 1; int k = 0; for(k=num;k>=1;k--){ res=res*k; } return res; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800 ~$ |
Em programas pequenos não é muito vantajoso usar variáveis públicas, quando o programa é muito grande, com mais de 1.00 linhas de texto é que usamos as variáveis públicas.
Analisemos o programa a seguir:
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> int v1 = 0; // Variáveis públicas começam aqui int v2 = 0; // Variáveis públicas começam aqui void funcao2(){ // public int v2 v1 = 200; v2 = 300; printf("Estamos na rotina FUNÇÃO 2... v1 = %d\n",v1); printf("v2 = %d\n",v2); } void funcao1(){ v1 = 100; printf("Extamos dentro da rotina FUNÇÃO 1... v1 = %d\n",v1); funcao2(); printf("Voltamos para FUNÇÃO 1... v1 = %d\n",v1); printf("v2 = %d\n",v2); } int main(int argc, char **argv){ printf("Exemplo de variável pública\n"); // public v1 v1=500; printf("Variável v1 antes da execução das rotinas %d \n",v1); funcao1(); printf("Estamos fora de FUNÇÃO 1 após sua execução v1 = %d\n",v1); return 0; } |
#include
<stdio.h> int v1 = 0; // Variáveis públicas começam aqui int v2 = 0; // Variáveis públicas começam aqui void funcao2(); void funcao1(); int main(int argc, char **argv){ printf("Exemplo de variável pública\n"); // public v1 v1=500; printf("Variável v1 antes da execução das rotinas %d \n",v1); funcao1(); printf("Estamos fora de FUNÇÃO 1 após sua execução v1 = %d\n",v1); return 0; } void funcao2(){ // public int v2 v1 = 200; v2 = 300; printf("Estamos na rotina FUNÇÃO 2... v1 = %d\n",v1); printf("v2 = %d\n",v2); } void funcao1(){ v1 = 100; printf("Extamos dentro da rotina FUNÇÃO 1... v1 = %d\n",v1); funcao2(); printf("Voltamos para FUNÇÃO 1... v1 = %d\n",v1); printf("v2 = %d\n",v2); } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Exemplo de variável pública Variável v1 antes da execução das rotinas 500 Extamos dentro da rotina FUNÇÃO 1... v1 = 100 Estamos na rotina FUNÇÃO 2... v1 = 200 v2 = 300 Voltamos para FUNÇÃO 1... v1 = 200 v2 = 300 Estamos fora de FUNÇÃO 1 após sua execução v1 = 200 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Exemplo de variável pública Variável v1 antes da execução das rotinas 500 Extamos dentro da rotina FUNÇÃO 1... v1 = 100 Estamos na rotina FUNÇÃO 2... v1 = 200 v2 = 300 Voltamos para FUNÇÃO 1... v1 = 200 v2 = 300 Estamos fora de FUNÇÃO 1 após sua execução v1 = 200 ~$ |
Resultado:
Exemplo de variável pública
Variável v1 antes da execução das rotinas 500
Estamos dentro da rotina FUNÇÃO1... v1= 100
Estamos na rotina FUNÇÃO2... v1=200
v2=300
Voltamos para FUNÇÃO1... v1=200
v2=300
Estamos fora de FUNÇÃO1 após sua execução v1=200
Declare esta variável no início do programa e não no meio ou no fim do programa; porque pode causar erros no programa.
Afinal o que Null?
1 - Null é um valor que indica dados ausentes ou desconhecidos em um campo
2 - nulo
3 - vazio
4 - sem valor
Assim como existe variáveis numéricas (var_1=9), variáveis strings (var_2="Texto") e variáveis booleanas (var_3=true) existem as variáveis nulas (var_4=null).
Atenção: encontrar variáveis nulas num código fonte são raros, mas de vez enquanto aparecem, os exemplos abaixo são simplesmente demonstrações.
Quando você quer limpar uma variável em faço o seguinte:
1º exemplo:
| Em C, arquivo com
erro: |
Em C, arquivo com erro: |
| /* Obs: em C as variáveis nulas (null) só são usadas em váriáveis String. Se usar outra varável numérica como int, double, float não vão funcionar. */ #include <stdio.h> #include <string.h> #include <stdlib.h> typedef enum {false=0, true=1} boolean; #define null "\0" int main(int argc, char **argv){ int Var_1; char Var_2[100]; boolean Var_3; Var_1 = 9; strcpy(Var_2,"Texto"); Var_3 = true; //Limpando as variáveis Var_1 = null; // Var_1 deu erro porque é um inteiro e não uma String Var_2 = null; // Var_2 deu erro Falha de segmentação Var_3 = null; // Var_3 deu erro porque é um booleano e não uma String return 0; } |
/* Obs: em C as variáveis nulas (null) só são usadas em váriáveis String. Se usar outra varável numérica como int, double, float não vão funcionar. */ #include <stdio.h> #include <string.h> #include <stdlib.h> typedef enum {false=0, true=1} boolean; #define null "\0" int main(int argc, char **argv){ int Var_1; char Var_2[100]; boolean Var_3; Var_1 = 9; sprintf(Var_2,"Texto"); Var_3 = true; //Limpando as variáveis Var_1 = null; // Var_1 deu erro porque é um inteiro e não uma String Var_2 = null; // Var_2 deu erro Falha de segmentação Var_3 = null; // Var_3 deu erro porque é um booleano e não uma String return 0; } |
| Resultado: |
Resultado: |
| O CÓDIGO DARÁ ERRO | O CÓDIGO DARÁ ERRO |
| Em C Só é válido
com String |
Em C Só é válido com String |
| #include
<stdio.h> #include <string.h> #include <stdlib.h> typedef enum {false=0, true=1} boolean; #define null "\0" int main(int argc, char **argv){ char Var_1[10]; char Var_2[10]; char Var_3[10]; strcpy(Var_1,"9"); strcpy(Var_2,"Texto"); strcpy(Var_3,"true"); //Limpando as variáveis strcpy(Var_1,null); strcpy(Var_2,null); strcpy(Var_3,null); printf("%s, %s, %s\n",Var_1,Var_2,Var_3); return 0; } |
#include
<stdio.h> #include <string.h> #include <stdlib.h> typedef enum {false=0, true=1} boolean; #define null "\0" int main(int argc, char **argv){ char Var_1[10]; char Var_2[10]; char Var_3[10]; sprintf(Var_1,"9"); sprintf(Var_2,"Texto"); sprintf(Var_3,"true"); //Limpando as variáveis sprintf(Var_1,null); sprintf(Var_2,null); sprintf(Var_3,null); printf("%s, %s, %s\n",Var_1,Var_2,Var_3); return 0; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo , , ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo , , ~$ |
2º exemplo:
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> #include <stdlib.h> #define null "\0" int main(int argc, char **argv){ char Nome[100]; char Sobrenome[100]; strcpy(Nome,null); strcpy(Sobrenome,null); if(strcmp(Nome,null)==0){ strcpy(Nome,"Marcos"); } if(strcmp(Sobrenome,null)==0){ strcpy(Sobrenome,"Aurelio"); } printf("%s %s\n",Nome,Sobrenome); return 0; } |
#include
<stdio.h> #include <string.h> #include <stdlib.h> #define null "\0" int main(int argc, char **argv){ char Nome[100]; char Sobrenome[100]; sprintf(Nome,null); sprintf(Sobrenome,null); if(strcmp(Nome,null)==0){ sprintf(Nome,"Marcos"); } if(strcmp(Sobrenome,null)==0){ sprintf(Sobrenome,"Aurelio"); } printf("%s %s\n",Nome,Sobrenome); return 0; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Marcos Aurelio ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo Marcos Aurelio ~$ |
3º exemplo:
| Arquivo: Exemplo.c |
Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> #include <stdlib.h> #define null "\0" int main(int argc, char **argv){ char a[10]; char b[10]; char c[10]; strcpy(a,"10"); strcpy(b,null); strcpy(c,"5"); int resp; if(strcmp(a,null)==0){ resp = atoi(b)+atoi(c); }else if(strcmp(b,null)==0){ resp = atoi(a)+atoi(c); }else if(strcmp(c,null)==0){ resp = atoi(a)+atoi(c); }else{ resp = atoi(a)+atoi(b)+atoi(c); } printf("%d\n",resp); return 0; } |
#include
<stdio.h> #include <string.h> #include <stdlib.h> #define null "\0" int main(int argc, char **argv){ char a[10]; char b[10]; char c[10]; sprintf(a,"10"); sprintf(b,null); sprintf(c,"5"); int resp; if(strcmp(a,null)==0){ resp = atoi(b)+atoi(c); }else if(strcmp(b,null)==0){ resp = atoi(a)+atoi(c); }else if(strcmp(c,null)==0){ resp = atoi(a)+atoi(c); }else{ resp = atoi(a)+atoi(b)+atoi(c); } printf("%d\n",resp); return 0; } |
| Resultado |
Resultado |
| ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 15 ~$ | ~$ gcc Exemplo.c -o Exemplo ~$ ./Exemplo 15 ~$ |
As funções são muito vantajosas para o usuário, pois permitem diminuir o tempo gasto na elaboração de formulários, assim como eventuais erros na sua concepção.
As funções do Javascript agrupam-se em:
As funções do Javascript tem a seguinte sintaxe:
| = nomedafunção(argumentos) |
Os tipos de argumentos variam de função para função e em relação às necessidades de cálculo do usuário.
Os tipos de argumentos mais utilizados são: variáveis numéricas, variáveis strings, variáveis booleanas, arrays e propriedades.
Exemplos (teóricos) de funções:
Inicio
escreva(
Potencia(2, 6) );
escreva(
Soma(12, 36) );
escreva(
Media(8, 3) );
Fim
Covertendo string para numérica
– atofConvertendo numérica para string
- sprintf
A função sprintf converte qualquer número (ponto flutuante ou inteiro)
para string
Sintaxe: char *sprintf(char *s, "%d", int num);
char *sprintf(char *s, "%f", float num);
Prototype: stdio.h
Exemplo:
char
str_a[30];
float flt_a = 2.598;
sprintf(str_a, "%f",
flt_a);
printf("float a =
%s\n", str_a);
char str_b[30];
int int_b = 234;
sprintf(str_b, "%d",
int_b);
printf("int a = %s\n",
str_b);
Funções matemáticas comuns
– absFunções trigonométricas
– sinLogarítmos
– log
A função log retorna o valor do logaritmo natural.
Sintaxe: double log (double x);
Prototype: math.h
- log10
A função log10 retorna o logarítmo na base 10.
Sintaxe: double log10 (double x);
Prototype: math.h
– exp
A função exp retorna o valor do expoente (ex).
Sintaxe: double exp (double x);
Prototype: math.h
As funções strcpy, strcmp, strcat são necessárias pois uma string nada mais é do que um vetor de caracteres, ou seja, não se pode atribuir vários valores (ao mesmo tempo) para os elementos de um vetor. Isto só pode ser feito quando o vetor é declarado e inicializado ou um de cada vez.
Exemplo:
char s[] = “UCPel”; // correto
ou
#define null
"\0"
s[0]
= ‘U’; // correto
– elemento por elemento
s[1]
= ‘C’;
s[2]
= ‘P’;
s[3]
= ‘e’;
s[4]
= ‘l’;
s[5]
= null;
ou
char s
= “UCPel”; // incorreto
– erro GRAVE em C
- strcpy
A função strcpy (cópia de string) pré-definida do C que permite copiar
uma string para outra ou inicializar uma string.
Sintaxe: char *strcpy (char *destino, const char *origem);
Prototype: string.h
Funcionamento: A string de origem é copiada para a string destino.
Programa exemplo (27): Os programas abaixo mostram como copiar
caracteres para uma string.
| Arquivo: Exemplo.c |
||
| #include
<stdio.h> #include <string.h> int main(void){ char erro[] = "Arquivo não Existe\n"; printf("ERRO: %s",erro); } |
#include
<stdio.h> #include <string.h> int main(void){ char erro[20]; strcpy(erro,"Arquivo não existe\n"); printf("ERRO: %s",erro); } |
#include
<stdio.h> #include <string.h> int main(void){ char erro[20]; sprintf(erro,"Arquivo não existe\n"); printf("ERRO: %s",erro); } |
- strcmp
A função strcmp (comparação de duas strings) pré-definida do C que
permite comparar duas strings.
a) s1 é maior que s2
resultado > 0
b) s1 é menor que s2
resultado < 0
c) s1 é igual a s2
resultado == 0
d) s1 é diferente de s2
resultado != 0
Sintaxe: int strcmp (const char *s1, const char *s2);
Prototype: string.h
Programa exemplo (28): O programa compara duas strings.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(void){ char s1[41],s2[41]; printf("String 1: "); scanf("%s",s1); printf("String 2: "); scanf("%s",s2); if (strcmp(s1,s2) == 0) printf("String 1 é IGUAL a String 2\n"); else if (strcmp(s1,s2) > 0) printf("String 1 é MAIOR a String 2\n"); else printf("String 1 é MENOR a String 2\n"); } |
3 - strcat
A função strcat (concatenação de duas strings) pré-definida do C que
permite a concatenação de uma string no final da outra string.
Sintaxe: char *strcat (char *destino, const char *origem);
Prototype: string.h
Funcionamento: A string origem é copiado para o final da string destino.
Programa exemplo (29): O programa cópia e concatena caracteres a uma
string resultando na palavra “Pelotas”.
| Arquivo: Exemplo.c |
|
| #include
<stdio.h> #include <string.h> int main(void){ char s1[] = "Pel",s2[] = "ota",s3[] = "s"; char sr[15] = ""; printf("%s\n",s1); printf("%s\n",s2); printf("%s\n",s3); strcpy(sr,s1); // sr = "Pel" strcat(sr,s2); // sr = "Pelot" strcat(sr,s3); // sr = "Pelotas" printf("%s\n",sr); } |
#include
<stdio.h> #include <string.h> int main(void){ char s1[] = "Pel",s2[] = "ota",s3[] = "s"; char sr[15] = ""; printf("%s\n",s1); printf("%s\n",s2); printf("%s\n",s3); sprintf(sr,"%s%s%s",s1,s2,s3); printf("%s\n",sr); } |
- strlen
A função strlen (comprimento de uma string) pré-definida do C que
retorna o comprimento de uma string, ou seja, a quantidade de
caracteres que a string possui no momento.
Observação: O NULL não é contado.
Sintaxe: int strlen (const char *s);
Prototype: string.h
Programa exemplo (30): O programa imprime na tela a quantidade de
caracteres de uma variável string, neste caso, a variável nome.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(void){ char nome[41]; printf("Qual o seu nome: "); scanf(“%s”,nome); printf("%s seu nome tem %d caracteres\n", nome, strlen(nome)); } |
– strchr
A função strchr (Verifica se um caracter pertence a uma string)
pré-definida do C que verifica se um caracter (chr) pertence a uma
string (str).
Sintaxe: int strchr (const char *s, char ch);
Prototype: string.h
Programa exemplo (31): O programa imprime na tela o número de
caracteres de um nome.
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int main(void){ char nome[41]; char ch; do { printf("Qual o seu nome: "); fgets(nome,40,stdin); printf("Seu nome tem %d caracteres\n", strlen(nome)); printf("Continua [S]im ou [N]ão ?"); do { ch = getchar(); } while (!strchr("SsNn",ch)); } while (strchr("Ss",ch)); } |
- Substring
| Arquivo:
Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> char *substring(char *origem, int inicio, int quant){ char *res = origem; int i = 0; // posição inicial menor que 0 ou // posição inicial muito exagerada? if((inicio < 0) || (inicio > strlen(origem))) inicio = 0; // quantidade de caracteres muito exagerada? if(quant > inicio + strlen(origem)) quant = strlen(origem) - inicio; // obtem os caracteres desejados for(i = 0; i <= quant - 1; i++){ res[i] = origem[inicio + i]; } // marca o fim da string res[i] = '\0'; return res; } void main(){ char texto[] = "Gosto muito de C e C++"; printf("%s\n",substring(texto, 6, 10)); } |
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> char *replace(char *st, char *orig, char *repl) { static char buffer[4096]; char *ch; if (!(ch = strstr(st, orig))) return st; strncpy(buffer, st, ch-st); buffer[ch-st] = 0; sprintf(buffer+(ch-st), "%s%s", repl, ch+strlen(orig)); return buffer; } void main(){ char texto[] = "Gosto muito de Java"; printf("%s\n",replace(texto,"Java","C e C++")); } |
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> void main(){ char texto[] = "Gosto muito de C e C++"; int x; for(x=0;x<strlen(texto);x++){ texto[x] = toupper(texto[x]); } printf("%s\n",texto); for(x=0;x<strlen(texto);x++){ texto[x] = tolower(texto[x]); } printf("%s\n",texto); } |
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> int indexOf(char *source,char *code){ char * found = strstr( source, code ); int index = -1; if (found != NULL){ index = found - source; } return index; } void main(){ printf("Index = %d\n",indexOf("test string","in")); } |
Existe apenas uma função para que se possa obter a data e a hora. É a função t= time('\0'); local=localtime(&t);. Esta funão devolve data e hora.
Para se obter os dados separadamente, existem os seguintes métodos:
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <time.h> #include <string.h> int main(int argc, char **argv){ struct tm *local; time_t t; t= time('\0'); local=localtime(&t); // ------------------- int dia=local->tm_mday; int mes=local->tm_mon; int ano=local->tm_year+1900; int dia_da_semana=local->tm_wday; // ------------------- char semana[][30] = {"Domingo", "Segunda", "Terça","Quarta", "Quinta", "Sexta", "Sabado"}; char semana_atual[30]; strcpy(semana_atual, semana[dia_da_semana]); // ------------------- char mes2[][30] = {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Desembro"}; char mes_atual[30]; strcpy(mes_atual, mes2[mes]); // ------------------- printf("%s, %d de %s de %d\n",semana_atual,dia,mes_atual,ano); // Retorna a data // ------------------- int horas=local->tm_hour; int minutos=local->tm_min; int segundos=local->tm_sec; printf("São: %d horas, %d minutos, %d segundos.\n",horas,minutos,segundos); // Retorna a hora return 0; } |
exemplo 4: alterando a data
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <string.h> #include <time.h> int main(int argc, char **argv){ // ------------------- int dia=4; int mes=11; int ano=2011; // ------------------- time_t rawtime; struct tm * timeinfo; time ( &rawtime ); timeinfo = localtime ( &rawtime ); timeinfo->tm_year = ano - 1900; timeinfo->tm_mon = mes - 1; timeinfo->tm_mday = dia; mktime ( timeinfo ); // ------------------- char semana[][30] = { "Domingo", "Segunda", "Terça","Quarta", "Quinta", "Sexta", "Sabado"}; char semana_atual[30]; strcpy(semana_atual, semana[timeinfo->tm_wday]); // ------------------- char mes2[][30] = {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Desembro"}; char mes_atual[30]; strcpy(mes_atual, mes2[mes-1]); // ------------------- printf("%s, %d de %s de %d\n",semana_atual,dia,mes_atual,ano); // Retorna a data return 0; } |
exmeplo 3: vendo as horas
| Arquivo: Exemplo.c |
| #include
<stdio.h> #include <time.h> int main(int argc, char **argv){ struct tm *local; time_t t; t= time('\0'); local=localtime(&t); // ------------------- int horas=local->tm_hour; int minutos=local->tm_min; int segundos=local->tm_sec; printf("São exatamente: %d%s%d%s%d\n",horas,(minutos < 10) ? ":0" : ":",minutos,(segundos < 10) ? ":0" : ":",segundos); } |