Post on 03-Nov-2020
Algoritmos e Estruturas de Dados IIEC012
Linguagem CLinguagem C– – Conceitos Básicos –Conceitos Básicos –
Prof. D.Sc. Leandro Galvãogalvao@icomp.ufam.edu.brwww.icomp.ufam.edu.br/galvaosala 1221
ConteúdoConteúdo
ConteúdoConteúdo
Algoritmo × ProgramaAlgoritmo × Programa
int a, b, c;int a, b, c;if (a > 2)if (a > 2)
a = b + c;a = b + c;elseelse
a = b – c;a = b – c;return;return;
AlgoritmoAlgoritmo
CódigoCódigo
RaciocínioRaciocínio
Do problema ao códigoDo problema ao código
CódigoCódigofontefonte
CódigoCódigoobjetoobjeto
Programa Programa ExecutávelExecutável
Geração de código Geração de código objetoobjeto
LinkagemLinkagem
DepuraçãoDepuração
CodificaçãoCodificação
Gerando um programa executávelGerando um programa executável
BibliotecasBibliotecas
Gerando um programa executável :: ResumoGerando um programa executável :: Resumo
PassoPasso
CodificaçãoCodificaçãoCodificaçãoCodificação
Geração de Geração de código-código-objetoobjeto
Geração de Geração de código-código-objetoobjeto
LinkagemLinkagemLinkagemLinkagem
FunçãoFunção
Escrita de código Escrita de código usando uma usando uma
linguagem de linguagem de programaçãoprogramação
Escrita de código Escrita de código usando uma usando uma
linguagem de linguagem de programaçãoprogramação
Tradução do Tradução do código-fonte para o código-fonte para o código de máquinacódigo de máquina
Tradução do Tradução do código-fonte para o código-fonte para o código de máquinacódigo de máquina
Rearranja o código-Rearranja o código-objeto, agregando objeto, agregando
funções das funções das bibliotecasbibliotecas
Rearranja o código-Rearranja o código-objeto, agregando objeto, agregando
funções das funções das bibliotecasbibliotecas
ResponsávelResponsável
Editor de Editor de textotexto
Editor de Editor de textotexto
CompiladorCompiladorCompiladorCompilador
LigadorLigadorLigadorLigador
ResultadoResultado
código-código-fontefonte
código-código-fontefonte
código-código-objetoobjetocódigo-código-objetoobjeto
código código executávelexecutável
código código executávelexecutável
ConteúdoConteúdo
Arquitetura de von NeumanArquitetura de von Neuman
CPUCPUCPUCPU InputInputInputInputMemóriaMemóriaMemóriaMemória
OutputOutputOutputOutput
BarramentoBarramento
Execução de um programaExecução de um programa
CPUCPUCPUCPU InputInputInputInputMemóriaMemóriaPrincipalPrincipal
MemóriaMemóriaPrincipalPrincipal OutputOutputOutputOutput
BarramentoBarramento
MemóriaMemóriaSecundáriaSecundáriaMemóriaMemória
SecundáriaSecundária
0101010101010101010101010101000101010100101011010110101101010001100101000110010101010101010101010101010101010101
Alocação de memória para um programaAlocação de memória para um programa
Dados dinâmicosDados dinâmicos(Heap)(Heap)
Dados dinâmicosDados dinâmicos(Heap)(Heap)
PilhaPilhaPilhaPilha
InstruçõesInstruções
Dados estáticosDados estáticos
códigocódigo
variáveis globaisvariáveis globais
alocações (malloc)alocações (malloc)
variáveis declaradas nas funçõesvariáveis declaradas nas funções
ProgramaPrograma
A partir de dados de entrada, a CPU realiza uma série de cálculos matemáticos e lógicos, gerando uma saída.
Programa é o elemento que diz ao computador quais cálculos devem ser realizados.
ProgramaProgramaentradaentrada saídasaída
Interface do software com o computadorInterface do software com o computador
ConteúdoConteúdo
A linguagem C é uma linguagem de programação genérica inventada na década de 1970 por Dennis Ritchie.
O ANSI (American National Standard Institute) padronizou a versão ANSI-C
http://en.wikipedia.org/wiki/C_programming_language
HistóricoHistórico
Por que estudar C?Por que estudar C?
Versatilidade: ele possui tanto características de “alto nível” quanto de “baixo nível”.
Aplicabilidade: possui ampla biblioteca de funções e é utilizado na construção de software para os mais diversos projetos.
Portabilidade: é possível adaptar um programa em C de uma arquitetura para outra.
Primeiros passosPrimeiros passos
Um programa em C consiste de várias funções encadeadas.
Todo programa deve conter uma única função main, que é o ponto de partida quando o programa é executado.
Funçãoargumentos valor de retorno
argumentos valor de retornoFunção 1
Função 2
Função N
main
O C é “Case Sensitive”O C é “Case Sensitive”
Caracteres maiúsculos e minúsculos são interpretados de forma diferente.
Soma ≠ soma ≠ SOMA ≠ SomASoma ≠ soma ≠ SOMA ≠ SomA
Estrutura GeralEstrutura Geral
tipo_de_retorno main(){
<comandos>return valor;
}
tipo_de_retorno main(){
<comandos>return valor;
}
int main() {
int x, y;x = x + y;return 0;
}
int main() {
int x, y;x = x + y;return 0;
}
Exemplo:
Especificam funções pré-definidas da linguagem.
Os primeiros comandos de um programa em C devem especificar as bibliotecas que serão utilizadas.
Exemplos:
stdio.h: biblioteca de funções de entrada e saída (leitura e escrita de dados).
math.h: biblioteca de funções matemáticas (potenciação, raiz quadrada, funções trigonométricas, etc.).
string.h: biblioteca de funções para manipulação de conjunto de caracteres (ex.: palavras).
1
BibliotecasBibliotecas
1
ComentáriosComentários
Podem ser escritos em qualquer lugar do código para facilitar a interpretação.
Tipos de comentários:
ConteúdoConteúdo
Devem ser declaradas antes de serem usadas, no início de um bloco de código.
Forma geral da declaração de variáveis:
tipo_da_variável lista_de_variáveis;tipo_da_variável lista_de_variáveis;
char letra;float temperatura, pressao;int dia, mes, ano;
char letra;float temperatura, pressao;int dia, mes, ano;
Exemplo:
VariáveisVariáveis
São os nomes que damos aos objetos utilizados (variáveis, constantes, funções, etc.)
Podem ter qualquer nome, desde que: Comecem com uma letra ou sublinhado (underscore) _ Os demais caracteres sejam letras, números ou _.
Não seja igual a: uma palavra reservada,
uma função declarada
bibliotecas do C.
Variáveis:: IdentificadoresVariáveis:: Identificadores
int _mesint ano_atualfloat temp1char palavra_digitada
int _mesint ano_atualfloat temp1char palavra_digitada
char 2a_feiraint valores$float floatint mainchar stdio
char 2a_feiraint valores$float floatint mainchar stdio
PermitidoPermitido Não permitido!Não permitido!
3
Variáveis:: Identificadores – ExemplosVariáveis:: Identificadores – Exemplos
Endereço
0000
0001
0002
0003
0004
...
FFFF
Conteúdo
Variáveis e gerenciamento de memóriaVariáveis e gerenciamento de memória
Variáveis são armazenadas na memória do computador.
Dados dinâmicosDados dinâmicos(Heap)(Heap)
Dados dinâmicosDados dinâmicos(Heap)(Heap)
PilhaPilhaPilhaPilha
InstruçõesInstruções
Dados estáticosDados estáticos
Tipos de dados primitivosTipos de dados primitivos
A linguagem C tem 5 tipos de dados primitivos:
Tipo Tamanho (bytes) Tamanho (bits)
char 1 8
int 4* 32*
float 4 32
double 8 64
* Depende do compilador
Tipos de dados:: Espaço em memóriaTipos de dados:: Espaço em memória
Um modificador de tipo altera o intervalo de valores que uma variável pode armazenar ou como o compilador representa um valor.
Existem quatro modificadores de tipo:
Tipos de dados:: ModificadoresTipos de dados:: Modificadores
Tipos de dados:: ModificadoresTipos de dados:: Modificadores
Os quatro modificadores podem ser aplicados ao tipo (int).
Ao tipo float não se pode aplicar nenhum modificador.
Ao tipo double pode-se aplicar apenas o modificador long.
Tipos de dados:: Resumo (compilador gcc)Tipos de dados:: Resumo (compilador gcc)
Tipo Tamanho em bits Faixa de números representados
char 8 -128 a 127unsigned char 8 0 a 255signed char 8 -128 a 127
int 32 -2.147.483.647 a 2.147.483.647unsigned int 32 0 a 4.294.967.295signed int 32 -2.147.483.647 a 2.147.483.647short int 16 -32.767 a 32.767
unsigned short int 16 0 a 65.535signed short int 16 -32.767 a 32.767
long int 32 -2.147.483.647 a 2.147.483.647unsigned long int 32 0 a 4.294.967.295signed long int 32 -2.147.483.647 a 2.147.483.647
float 32 seis dígitos de precisãodouble 64 dez dígitos de precisão
long double 80 dez dígitos de precisão 2
#define <identificador> <valor>#define <identificador> <valor>
#define PI 3.1415#define ANO 2007#define LETRA ' A'
#define PI 3.1415#define ANO 2007#define LETRA ' A'
Exemplos:
ConstantesConstantes
São valores fixos que não podem ser modificados em nenhuma parte do programa.
Sua definição não usa ponto-e-vírgula, nem sinal de igualdade.
ConstantesConstantes
Costuma-se definir o nome das constantes com letras maiúsculas, para diferenciá-los de nomes de variáveis e funções.
Essa prática melhora a legibilidade do programa e facilita a manutenção do programa.
4
Uma variável, ao ser definida, contém um valor qualquer e imprevisível. Costuma-se dizer que contém lixo de memória.
O comando de atribuição (=) permite alterar o valor (conteúdo) de uma variável.
<variável> = <valor>;<variável> = <valor>;
Operador de AtribuiçãoOperador de Atribuição
letra = 'H';
ano = 2007;
temperatura = 38.9;
nova_letra = letra;
float cateto = 3.1;
area_ret = base * altura;
letra = 'H';
ano = 2007;
temperatura = 38.9;
nova_letra = letra;
float cateto = 3.1;
area_ret = base * altura;
Exemplos:
ConteúdoConteúdo
OperadoresOperadores
Operadores AritméticosOperadores Aritméticos
São utilizados para a realização de operações aritméticas básicas.
Operador Operação Exemplo
+ Adição x = 1 + y;
- Subtração x = x – y;
* Multiplicação x = 8 * y;
/ Divisão x = y / 2;
% Resto de divisão x = y % 2;
++ Incremento x++;
-- Decremento y--;
- Negação -z;
operadoresunários (um argumento)
Operadores AritméticosOperadores Aritméticos
Entrada: 01 ou 02 valores numéricos.
Saída: 01 valor numérico.
OperadorOperadorAritméticoAritmético
valor numéricovalor numérico
valor numéricovalor numéricovalor numéricovalor numérico
Operadores Aritméticos:: Incremento e decrementoOperadores Aritméticos:: Incremento e decremento
O operador incremento de 1 (++) realiza duas operações: Soma 1 ao valor atual da variável
Armazena o resultado na própria variável
O operador decremento de 1 (--) funciona de forma semelhante.
x = x + 1;x = x + 1; x++;x++;
x = x - 1;x = x - 1; x--;x--;
Os operadores ++ e -- podem ser usados como: Prefixos:antes da variável: ++x
Sufixos: após a variável: x++
Se a operação aparece isolada, ambas notações são equivalentes:
int n = 6, m = 3;n++; /* resultado: n = 7 */++m; /* resultado: m = 4 */n--; /* resultado: n = 6 */--m; /* resultado: m = 3 */
int n = 6, m = 3;n++; /* resultado: n = 7 */++m; /* resultado: m = 4 */n--; /* resultado: n = 6 */--m; /* resultado: m = 3 */
6
Operadores Aritméticos:: Incremento e decrementoOperadores Aritméticos:: Incremento e decremento
Se a operação é parte de uma expressão: Prefixo: Valor usado na expressão é o valor
incrementado/decrementado. Sufixo: Operação incremento/decremento será realizada
depois que o valor for usado na expressão.
int n = 0, m = 0, a, b, c, d;n++; /* resultado: n = 1 */++m; /* resultado: m = 1 */n--; --n; /* resultado: n = -1 */a = n++; /* resultado: a = -1; n =0 */b = ++m; /* resultado: b = 2; m = 2*/c = 2*(m++); /* resultado: c = 4; m = 3*/d = 3*(++n); /* resultado: d = 3; n = 1*/
int n = 0, m = 0, a, b, c, d;n++; /* resultado: n = 1 */++m; /* resultado: m = 1 */n--; --n; /* resultado: n = -1 */a = n++; /* resultado: a = -1; n =0 */b = ++m; /* resultado: b = 2; m = 2*/c = 2*(m++); /* resultado: c = 4; m = 3*/d = 3*(++n); /* resultado: d = 3; n = 1*/
7
Operadores Aritméticos:: Incremento e decrementoOperadores Aritméticos:: Incremento e decremento
Operadores RelacionaisOperadores Relacionais
Estabelecem relação de comparação entre valores numéricos.
Produzem um resultado lógico:
Operador Operação
> Maior do que
>= Maior ou igual a
< Menor do que
<= Menor ou igual a
== Igual a
!= Diferente de
Operadores RelacionaisOperadores Relacionais
Entrada: 02 valores numéricos.
Saída: 01 valor lógico.
OperadorOperadorRelacionalRelacional
valor numéricovalor numérico
valor numéricovalor numéricovalor lógicovalor lógico
int cond;int a = 3; float x = 1.5;
cond = a != x; /* cond=1 -> V */cond = a/2.0 == x; /* cond=1 -> V */cond = a/2 == x; /* cond=0 -> F */cond = a != 2*x; /* cond=0 -> F */cond = a >= x; /* cond=1 -> V */cond = a/3 <= x; /* cond=1 -> V */cond = a/2 > 2; /* cond=0 -> F */cond = a; /* cond=3 -> V */cond = a – 2*x; /* cond=0 -> F */
int cond;int a = 3; float x = 1.5;
cond = a != x; /* cond=1 -> V */cond = a/2.0 == x; /* cond=1 -> V */cond = a/2 == x; /* cond=0 -> F */cond = a != 2*x; /* cond=0 -> F */cond = a >= x; /* cond=1 -> V */cond = a/3 <= x; /* cond=1 -> V */cond = a/2 > 2; /* cond=0 -> F */cond = a; /* cond=3 -> V */cond = a – 2*x; /* cond=0 -> F */
10
Operadores Relacionais:: ExemplosOperadores Relacionais:: Exemplos
Operadores LógicosOperadores Lógicos
Efetuam avaliações entre valores lógicos. Operador Ação
&& AND (E)
|| OR (OU)
! NOT (NÃO)
Operadores LógicosOperadores Lógicos
Entrada: 01 ou 02 valores lógicos.
Saída: 01 valor lógico.
OperadorOperadorLógicoLógico
valor lógicovalor lógico
valor lógicovalor lógicovalor lógicovalor lógico
int cond;int a = 3; float x = 1.5;
cond = (a/2 == x) && (a > 2); /* cond=0 -> F */cond = (a != x) || (a/x < 2); /* cond=1 -> V */cond = (x <= a) && (a >= 2*x); /* cond=1 -> V */cond = !(a/3 <= x); /* cond=0 -> F */cond = (a/2==x) || (a>=x) && !(2*x!=a); /* cond=1 -> V */cond = a && x; /* cond=1 -> V */cond = (a - 2*x) || (x < a/2); /* cond=0 -> F */
int cond;int a = 3; float x = 1.5;
cond = (a/2 == x) && (a > 2); /* cond=0 -> F */cond = (a != x) || (a/x < 2); /* cond=1 -> V */cond = (x <= a) && (a >= 2*x); /* cond=1 -> V */cond = !(a/3 <= x); /* cond=0 -> F */cond = (a/2==x) || (a>=x) && !(2*x!=a); /* cond=1 -> V */cond = a && x; /* cond=1 -> V */cond = (a - 2*x) || (x < a/2); /* cond=0 -> F */
11
Operadores Lógicos:: ExemplosOperadores Lógicos:: Exemplos
Operadores bit a bitOperadores bit a bit
Não enxergam as variáveis com um valor único, mas sim como um conjunto de bits.
Atuam sobre os bits individuais de uma variável.
Não confundir com operadores lógicos.
Operador Ação
& AND
| OR
^ XOR (OR exclusivo)
~ NOT
>> Deslocamento de bits à direita
<< Deslocamento de bits à esquerda
8
Precedência entre operadoresPrecedência entre operadores
++ --
-
!
Pré/pós incremento, decremento
Menos Unário
Negação
* /
%
Multiplicação, divisão
Módulo (resto da divisão inteira)
+ - Subtração, adição
> >= < <= Relacionais
== != Igual, diferente
&& E lógico
|| OU lógico
= += -= *= /= Atribuição
ConteúdoConteúdo
Estão descritos na biblioteca stdio.h
Comandos de Entrada e SaídaComandos de Entrada e Saída
printf (string_de_controle, argumentos);printf (string_de_controle, argumentos);
Comandos de Saída :: printf()Comandos de Saída :: printf()
Função para a escrita formatada no dispositivo de saída padrão, normalmente o vídeo.
string_de_controle consiste em: Caracteres que serão exibidos na tela Caracteres de controle (\) Comandos de formato, que definem a maneira como os
argumentos serão mostrados (%) argumentos são as variáveis cujos conteúdos serão
exibidos na tela.
Comandos de Saída:: Caracteres de controle do printf()Comandos de Saída:: Caracteres de controle do printf()
Imprimem caracteres especiais na saída:
Comandos de Saída :: Comandos de formato do printf()Comandos de Saída :: Comandos de formato do printf()
Determinam a interpretação do espaço de memória impresso
12
Comandos de formato podem ser alterados para especificação da largura mínima de campo ou do número de casas decimais:
%[alinhamento][tamanho][.][precisão]formato%[alinhamento][tamanho][.][precisão]formato
Comandos de Saída :: printf()Comandos de Saída :: printf()
0: completa com zeros à esquerda para atingir o tamanho especificado-: força alinhamento à esquerda
Especifica número de caracteres a serem impressos, incluindo o sinal e o ponto decimal.
Especifica número de casas decimais a serem impressas.
13
14
Comandos de Saída :: putchar()Comandos de Saída :: putchar()
Escreve um caractere na tela a partir da posição atual do cursor.
O resultado do comando é a impressão do caractere corresponde ao código ASCII do argumento.
Argumento pode ser do tipo int ou char.
putchar (<variável>);putchar (<variável>);
15
Comandos de Entrada :: scanf()Comandos de Entrada :: scanf()
Rotina de leitura formatada de dados inseridos pelo usuário pelo teclado.
string_de_controle: comandos de formato (%_), os mesmos relacionados para o printf().
argumentos: endereço das variáveis onde serão colocados os valores de entrada: &nome_variável.
O operador & representa o endereço de uma variável.
scanf (string_de_controle, argumentos);scanf (string_de_controle, argumentos);
16
Rotina de entrada que lê uma sequência de caracteres (string) até que seja pressionada a tecla ENTER.
17
gets(nome_da_variável);gets(nome_da_variável);
Comandos de Entrada :: gets()Comandos de Entrada :: gets()
18
nome_da_variável = getchar();nome_da_variável = getchar();
Comandos de Entrada :: getchar()Comandos de Entrada :: getchar()
Rotina que espera uma tecla ser pressionada e devolve seu valor na tela.
Deve-se pressionar ENTER depois de digitar o caractere.
Não fazem parte do ANSI-C padrão:
getche() – lê caractere, exibe na tela, dispensa ENTER.
getch() – lê caractere, não exibe na tela, dispensa ENTER.
Dúvidas?Dúvidas?
Tabela ASCIITabela ASCII
American Standard Code for Information Interchange (ASCII) é um conjunto de códigos para o computador representar números, letras, pontuação e outros caracteres.
http://pt.wikipedia.org/wiki/ASCII
Binário Decimal Hex Caractere0100 0001 65 41 A0100 0010 68 42 B0100 0011 67 43 C0010 1011 43 2B +0011 0001 49 31 1