RESUMO linguagem C // Lógica da Programação e Algoritmos

Prévia do material em texto

Lógica da 
programação e 
algoritmos II sue 
Capítulo I 
Conceitos: A programação 
inicia com a escrita do 
código fonte e encerra com 
a geração de um programa 
executável. A compilação 
torna o que foi digitado em 
algo objeto, que é a versão 
em linguagem de máquina. 
 
Estrutura: 
#include <stdio.h> 
main() 
{ 
printf("Hello, World"); 
return (0); 
} 
 
Identificadores: 
Maiusculas ≠ minúsculas. 
Válidos: A, a, media, 
altura2, media_idade, x36 
etc. 
Inválidos: 2ª, b@, media 
idade, x*y, #media, idade! 
etc. 
→ Tipos de dados: 
char: caractere. 
int: números inteiros. 
float: números flutuantes/ 
6.1 5.21 etc. 
double: flutuantes de 
posição dupla. 
enum: dados enumerados. 
void: sem valor/ 0 bits. 
pointer: localização na 
memória. 
 
Palavras reservadas: 
Identificadores que 
possuem uso específico. 
 
Variáveis: Espaços na 
memória principal. Seu uso 
é semelhante ao de uma 
gaveta. 
 
Constante: Valores que 
não variam com o tempo. 
#define <identificador> 
valor 
 
Expressões aritméticas: 
Soma + 
Subtração - 
Multiplicação * 
Divisão / 
Resto % 
 
Relacionais: 
Operador Símbolo 
Igual == 
Diferente ! = 
Maior > 
Menor < 
Maior ou 
igual 
>= 
Menor ou 
igual 
<= 
 
Operadores lógicos: 
Operador Símbolo 
Conjunção && 
Disjunção || 
Negação ! 
Conjunção é quando ambos 
os valores são verdadeiros. 
Disjunção quando um dos 
dois é verdadeiro. Negação 
inverte o valor. 
 
Funções intrínsecas: São 
fórmulas matemáticas 
prontas que 
 
Atribuição: = 
 
Entrada de dados: cin, 
gets e scanf. 
scanf(“%d”, &idade); 
%c: leitura de caractere. 
%d:leitura de N inteiro. 
%f: leitura de N float. 
%s: leitura de uma string. 
Saída de dados: printf 
\n Nova linha 
\t Tab 
\b Retrocesso 
\” Aspas 
\\ Comentário 
\f Salta 
formulário 
\0 Nulo 
 
Capítulo II 
Estrutura condicional 
simples: Só executa se for 
verdadeiro. 
if (<condição>) 
{ 
<instruções para 
condição verdadeira>; 
} 
 
Estrutura condicional 
composta: Se for V, faz o 
arranjo de coisas para V. 
Se for F, faz o arranjo de 
coisas para F. 
if (<condição>) 
{ 
<instruções para 
condição verdadeira>; 
} 
else 
{ 
<instruções para 
condição falsa>; 
} 
 
Estrutura case (switch): 
Em case há inúmeras 
possibilidades, mas, uma 
boa referência é que 
funciona como um cardápio, 
para cada item há um 
arranjo. 
switch (<variável>) { 
case <valor 1> : 
<instruções>; 
 break; 
case <valor 2> : 
<instruções>; 
 break; 
case <valor 3> : 
<instruções>; 
 break; 
default: <instruções>; 
} 
Capítulo III 
Estrutura de repetição: 
→ for: Usada para um 
número definido de 
repetições. Serve para 
quando sabemos 
previamente a quantidade 
de vezes que o trecho do 
código precisa ser repetido. 
for ( i= valor inicial; 
condição; incremento ou 
decremento de i) 
{ 
 <instruções>; 
} 
 
→ while: É um tipo de laço 
condicional. Ela é útil 
quando temos um número 
indefinido de repetições e 
se caracteriza por fazer um 
teste condicional no início. 
while (condição) 
{ 
 <instruções>; 
} 
 
→ do while: Também é 
condicional e tem um 
número indefinido de 
repetições, porém a 
instrução fica no fim, ou 
seja, ela é executada ao 
menos uma vez. 
do 
{ 
 <instruções>; 
} 
while (condição); 
 
Capítulo IV 
Vetores: Um arranjo de 
elementos armazenados na 
memória principal, todos 
com o mesmo nome e do 
mesmo tipo. 
Ex: 
#include <stdio.h> 
main() 
{ 
 int vetorA[10]; 
 int i; 
 for (i = 0; i < 10; 
i++) 
 { 
 printf("\n 
Digite o %d elemento do 
vetor:", i); 
 scanf("%d", 
&vetorA[i]); 
 } 
 printf("\n Vetor 
preenchido"); 
 for (i = 0; i < 10; 
i++) 
 { 
 printf("\n O 
elemento na posicao %d e: 
%d", i, vetorA[i]); 
 } 
 return (0); 
} 
 
Ordenação em vetor: 
Significa rearranjar os 
elementos para facilitar a 
localização. 
→ Método bolha: Consiste 
em percorrer o vetor 
repetidas vezes, 
comparando os elementos 
vizinhos. Se eles estão fora 
de ordem, é efetuada uma 
troca de posição. 
Pesquisa em vetor: 
→ Pesquisa sequencial: 
Consiste em percorrer o 
vetor a partir do primeiro 
elemento, sequencialmente, 
até o último, realizando 
testes lógicos no intuito de 
verificar se o elemento de 
determinada posição é igual 
ao elemento curado. 
Strings: char / char 
nome_string[tamanho]; 
Matrizes: É um tipo de 
dado formado por uma 
sequência do mesmo tipo 
(homogêneas), alocadas 
sequencialmente na 
memória. 
Ex: 
#include <stdio.h> 
main() 
{ 
 int matrizA[2][10]; 
 int i, j; 
 for (i = 0; i < 2; 
i++) 
 { 
 for (j = 0; j 
< 10; j++) 
 { 
 
 printf("\n Digite o 
%d %d elemento da 
matriz:", i, j); 
 
 scanf("%d", 
&matrizA[i][j]); 
 } 
 } 
 for (i = 0; i < 2; 
i++) 
 { 
 for (j = 0; j 
< 10; j++) 
 { 
 
 printf("\nO 
elemento da posicao %d %d 
e: %d", i, j, 
matrizA[i][j]); 
 } 
 } 
 return (0); 
} 
 
Estruturas: Em matrizes e 
vetores conseguimos 
manipular uma grande 
quantidade de dados, 
porém esses dados só 
podem ser do mesmo tipo. 
As estruturas solucionam 
isso, já que nos permitem 
agregar várias informações 
diferentes. 
O acesso aos elementos 
não é realizado por meio de 
sua localização, mas sim 
por meio do nome do 
campo que se pretende 
acessar. 
 
 
 
struct nome_da_estrutura 
{ 
 tipo_de_dado do 
campo 1; 
 tipo_de_dado do 
campo 2; 
 . . . 
 tipo_de_dado 
do campo n; 
}; 
 
Capítulo V 
Funções: Para solucionar 
problemas complexos nós 
tendemos a diminuí-los em 
problemas mais simples. 
Logo, uma função é uma 
sub-rotina que tem como 
objetivo desviar a execução 
do programa principal para 
resolver esses 
contratempos menores. 
tipo_de_retorno 
nome_da_função 
(declaração_de_parâmetr
os) 
{ 
corpo_da_função 
} 
Variáveis locais: Podem 
ser utilizadas apenas dentro 
de uma função. Depois são 
destruídas e seus 
componentes perdidos. 
Variáveis globais: São 
declaradas fora das funções 
e acessíveis em qualquer 
parte do programa. Ocupa 
mais memória e também é 
destruída após a execução. 
Passagem de parâmetros: 
Recebem valor no momento 
em que são chamadas. 
→ Passagem de 
parâmetros por valor: Não 
altera o valor do parâmetro 
real quando o parâmetro 
formal é manipulado na 
função. 
→ Passagem de 
parâmetros por 
referência: Consistem em 
endereços na memória 
ocupados por variáveis. 
Recursividade: Consiste 
em uma função que chama 
a si mesma. (pág 176 do 
livro)