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