Conceitos básicos de programação em C: variáveis, estruturas de dados e funções, Exercícios de Programação em C

Baixe Conceitos básicos de programação em C: variáveis, estruturas de dados e funções e outras Exercícios em PDF para Programação em C, somente na Docsity!

Introdução à linguagem C

Centro Nacional de Alto Desempenho CENAPAD-SP Prof. Carlos Rebollo Abril de 2013

1 Sumário

1 Introdução

1.1 O Curso....................................................................................................................

O curso foi estruturado em cinco aulas sendo cada aula tendo uma parte teórica e uma parte prática com exercícios e laboratórios. Os capítulos seguem a sequencia das aulas. 1 Introdução 2 Aula 1: Estrutura de um programa C, declaração de variáveis primitivas e valores literais. 3 Aula 2: Declaração de variáveis derivadas e construção de expressões. 4 Aula 3: Controles de fluxos, estrutura de funções, blocos e escopo. 5 Aula 4: Gerenciamento de memória 6 Aula 5: Biblioteca padrão C e entrada/saída 7 Material Extra:

1.2 A tipografia usada na apostila:.................................................................................

Esse item é obrigatório [item] Esse item é opcional Exemplo if( <expressão lógica> ) [else ] O comando “if” obrigatoriamente recebe um parâmetro <expressão lógica> e um . Opcionalmente depois pode-se ter o “else”. Mas se tivermos o comando “else”, obrigatoriamente teremos um depois. Exemplo: if( 1 > 2 ) comando1(); else comando2();

2 Aula 1

2.1 Acesso ao ambiente CENAPAD utilizando Windows.

1. clica-se no ícone do putty
2. Na tela de conexão do putty Na primeira vez preencha hostname e saved session com cenapad.unicamp.br. Depois clica-se save. Depois de salvo, clica-se open. Nas outras vezes somente clica-se na sessão salva, e depois open.
3. No terminal preencha o login e password com as informações da conta recebida no primeiro dia de aula.

2.1.1 Acesso ao ambiente pelo linux

Para acessar o ambiente pelo linux, utilizamos o ssh. O usuário tem que ser substituindo usuario pelo login passado no primeiro dia de aula. #ssh [email protected] Password:

2.1.2 Sobre o ambiente CENAPAD.

Os ambientes CENAPAD tem como sistema operacional o Linux ou Unix. No curso vamos ver alguns comandos básicos para poder editar os exemplos e exercícios. Diretório atual #pwd Listar arquivos e pastas #ls Entrar em uma pasta #cd pasta #cd curso_c Sair dessa pasta #cd .. Copiar um arquivo #cp origem destino #cp exemplo01.c teste.c Renomear um arquivo #mv origem destino #mv teste.c teste01.c O ambiente CENAPAD não tem programas gráficos para edição de arquivos. Os editores em linha de comando são o vi e o nano. Para quem já conhece essas ferramentas poderá escolher a que é mais confortável. Quem está conhecendo agora, indicamos o nano pela facilidade nos comandos. Editar um arquivo existente #nano arquivo #nano teste01.c Para navegar entre as linhas ou posições utilize as teclas “seta” Para sair do programa tecle Ctrl+X Se o arquivo não foi alterado, o programa sai sem perguntar nada. Se for um arquivo alterado, ele perguntará “Save modiffied buffer” Digite “Y”. Ele confirmará o nome do arquivo, apenas tecle “Enter”.

2.1 Primeiro Programa em C

exemplo01.c 1./*

2. • nome: exemplo01.c
3. • descrição: primeiro exemplo em C
4. • data: 17/08/
5. */ 6.#include <stdio.h> 7.int main() 8.{
6. // imprime Bom dia
7. printf(“Bom dia\n”);
8. return 0; 12.}

Logo depois, na linha 7 “int main()” é a definição de uma função em C. Nesse caso a função com o nome “main” ( principal em inglês). Um programa pode ter várias funções mas somente uma com o nome “main” que indica aonde o programa iniciará quando for executado. Alias, o C é “case-sensetive” e diferencia letras minúsculas de maiúsculas: “main” é diferente de “MAIN” e é diferente de “Main”. A função “main” tem uma palavra antes o “int” que é uma palavra que define um tipo de dado em C que representa inteiro. A função “main” que por analogia da matemática (y = f(x)) tem um valor de retorno, valor de resultado da função. ➔ Programas tem uma função “main” mas se estivermos programando bibliotecas que apenas disponibilizam uma coleção de funções, não teríamos a função “main” e o programador que for usar essa biblioteca é que vai definir um “main” em seu programa. A função “main” inicia na linha 8 com o caractere “{“ e termina na linha 12 com o caractere “}”. Toas as linhas entre a 8 e 12 estão na função “main” ou mais tecnicamente no escopo da função “main”. Toda a linha de comando em C termina com “;”. Na linha 11 temos uma outra função a “printf” que como analogia a funções em matemática ( y = f(x) ), recebe como parâmetro um texto “Bom dia\n”. A função “printf” imprime na tela do usuário o que recebe como parâmetro ( “Bom dia\n” ). Na linha 12 temos a linha “return 0;” que é um comando especial que além de sair da função, e nesse caso do programa, ela especifica o valor de retorno. ➔ Funções retornam ao ponto que ela foi chamado. No caso de “main”, ela retorna para quem executou o programa. A convenção é que quando retornamos zero ( 0 ) num programa, quer dizer que ele funcionou como esperado e se tiver valor diferente de zero, seria o número de algum erro. Agora vamos compilar esse primeiro exemplo: Na pasta exemplos executamos: icc -o exemplo01 exemplo01.c -Wall Para executar o programa: ./exemplo Saída na tela: Bom dia Note que os caracteres “\n” não são exibidos porque essa sequencia representa o carácter de nova-linha. Existem outras sequencias especiais que veremos durante o curso.

2.2.1 O comando printf

Durante o curso usaremos o “printf” como ferramenta nos nossos laboratórios. Agora apresentaremos o básico necessário para os laboratórios e no último dia veremos melhor a formatação de dados. // formato do printf printf(“string formatação”, [var, var, var,...]);

A “string de formatação” é um texto que podemos escrever literalmente ou podemos indicar locais para a inclusão de variáveis usando “%” e um qualificador que define o tipo e a formatação de saída de cada item. Para cada “%” que achamos, ele ira usar uma variável da lista de variáveis. printf(“%d %d %d \n”, 1 , 2 , 3 ); para cada %d o printf coloca o valor do próximo literal ou variável Letra Descrição i ou d Inteiro u Inteiro sem sinal o Octal sem sinal X ou x Hexadecimal sem sinal F ou f Ponto flutuante. E ou e Ponto flutuante notação cientifica. G ou g Usar a melhor representação e ou f A ou a Ponto flutuante em hexadecimal com sinal c Caractere. s String p Ponteiro Se colocarmos um %x que não condiz com o tipo da variável ou literal, o compilador avisará mas deixará passar. Quando for executado, esse erro ficará aparente. Exemplo02.c 1./*

2. • nome: exemplo02.c
3. • descrição: Printf
4. • data: 08/04/
5. */ 6.#include <stdio.h> 7.int main() 8.{
6. // O comando printf
7. printf("Bom dia\n");
8. printf("L11) 10 = %d,%i,%u,%o,%x\n",10,10,10,10,10);
9. printf("L12) -10 = %d,%i,%u,%o,%x\n",-10,-10,-10,-10,-10);
10. printf("L13) 0.10 = %f,%e,%g,%a,%x\n",0.10,0.10,0.10,0.10,0.10);
11. printf("L14) -0.10 = %f,%e,%g,%a \n" ,-0.10,-0.10,-0.10,-0.10);
12. printf("L15) char = %c string = %s\n", 'a' ,"Bom dia");
13. return 0 ; 17.}

2.3 Tipo de dado em C.................................................................................................

Como a linguagem C é de tipagem estática, tanto os valores literais quanto variáveis são de um tipo de dado definido. Podemos separar esses tipos de dados em primitivos e derivados. Os tipos de dados primitivos são definidos pela linguagem de programação, os derivados são definidos pelo programador compondo com tipos primitivos ou usando tipos derivados já definidos. Os tipos de dados primitivos podem ser divididos didaticamente em grupos:

• Numéricos inteiros: representam números naturais sem fração.
• Numéricos ponto flutuante: representam números reais com fração.
• Caractere: Representam somente um caractere. Esses grupos de tipos de dados são escalares podendo realizar todas as operações matemáticas, lógicas e comparativas. Isso é natural para números mas o caractere é a representação em bit de um valor numérico e essa representação é definida pela tabela ASCII ( letra 'a' é o número 97). Os tipos de dados derivados:
• String: Em C string é um vetor de vários caracteres.
• Array: Estrutura que podemos agrupar valores em formato de vetores ou matrizes de vária dimensões. Cada um pode ser referenciado pelo um índice numérico.
• Struct: Estrutura que podemos agrupar variáveis de tipo diferente. Cada variável componente é referenciada pelo nome dela.
• Union: Estrutura análoga ao struct mas todas as variáveis ocupam o mesmo espaço na memória. Usado para economizar memória.
• Enum: Estrutura de dado aonde posso enumerar opções usando nomes.

2.4 Declaração de Variáveis primitivas........................................................................

Para usar variáveis em C precisamos primeiramente declara-la informando o nome e o tipo dela. nome; // Se formos declarar uma variável do tipo int ( inteiro ). int contador; Podemos também declarar variáveis do mesmo tipo na mesma linha separadas por virgula. var1, var2, varn; // Se formos declarar x,y,z como int ( inteiro ) int x,y,z; As variáveis em C, por padrão, não são inicializadas, o compilador apenas reserva a memória necessária ao tipo dela. Essa posição de memoria pode conter alguma informação de um programa que foi executado

antes. Depois que um programa executa, a memória não é apagada e sim sobreposta por outro programa. Para inicializar uma variável atribuímos algum valor neutro para essa variável. Podemos aproveitar a declaração da variável para a inicialização dela. nome=valor; // Para inicializar o contador int contador=1; // Podemos também declarar e inicializar várias variáveis int x=0,y=0,z=0; //Podemos inicializar a variável depois de declarar int contador; int x,y,z; contador =1; x=0; y=z=0; Um exemplo completo seria: exemplo03.c 1./*

2. • nome: exemplo03.c
3. • descrição: Declaração e inicialização de variáveis
4. • data: 11/02/
5. */ 6.#include <stdio.h> 7.int main() 8.{
6. // Declaração e inicialização de variáveis
7. int contador=0;
8. int x=1,y=1;
9. char c;
10. c='x';
12. printf(“Bom dia\n”);
13. printf(“contador=%d\n”,contador);
14. printf(“x=%d, y=%d\n”,x,y);
15. printf(“c=%c\n”,c);
17. return 0; 21.}

2.5 Tipos de dados primitivos e variáveis.....................................................................

Os tipos de dados primitivos podem ser divididos em grupos:

• Numéricos inteiros: representam números naturais sem fração.
• Numéricos ponto flutuante: representam números reais com fração.

7.int main() 8.{

9. short int km;
10. unsigned short int idade;
11. long int cm;
12. unsigned long int saldo_cc;
13. long long int mm;
14. unsigned long long int moleculas;
15. return 0; 16.} Podemos verificar se o ambiente que estamos usando segue o padrão C usando a função sizeof. Essa função retorna a quantidade de bytes que são 8 bits. exemplo05.c 1./*
16. • nome: exemplo05.c
17. • descrição: Declaração de variáveis inteiras
18. • data: 03/10/
19. */ 6.#include <stdio.h> 7.int main() 8.{
20. printf(“short int = %lu\n”, sizeof(short int));
21. printf(“unsigned short int = %lu\n”, sizeof(unsigned short int));
22. printf(“long int = %lu\n”, sizeof(long int));
23. printf(“unsigned long int = %lu\n”, sizeof(unsigned long int));
24. printf(“long long int = %lu\n”, sizeof(long long int));
25. printf(“unsigned long long int = %lu\n”, sizeof(unsigned long long int));
26. return 0; 16.}

2.6.2 Numéricos ponto flutuante

No C números de ponto flutuante pode ser representado por float ou double e suas variações. Essas variações definem a capacidade de representação numérica. Quanto maior a quantidade de bits, maior a capacidade de representação numérica. Se o valor extrapolar esse limite pode ocorrerá problemas overflow e underflow. Overflow pode ser como o exemplo com números inteiros. Já o Undeflow é quando um número é tão pequeno como 0,000000000001 com 12 casas, mas o tipo somente aceitaria 10 e nesse caso ele seria arredondado para zero. Essas definições de capacidade de variável podem variar de acordo com a arquitetura e do ambiente computacional e se for preciso terá que ser tradada pelo programador (Faça a linguagem rápida, mesmo que não tenha portabilidade). Tipo Capacidade float 16 bits

double 62 bits long double 64 bits A declaração de variáveis segue a mesma regra: nome; Um exemplo no código fonte exemplo06.c 1./*

2. • nome: exemplo06.c
3. • descrição: Declaração de variáveis ponto flutuante.
4. • data: 08/04/
5. */ 6.#include <stdio.h> 7.int main() 8.{
6. float km;
7. double cm;
8. long double mm;
9. return 0; 13.} Podemos verificar se o ambiente que estamos usando segue o padrão C usando a função sizeof. Essa função retorna a quantidade de bytes que são 8 bits. exemplo07.c 1./*
10. • nome: exemplo07.c
11. • descrição: Declaração de variáveis inteiras
12. • data: 03/10/
13. */ 6.#include <stdio.h> 7.int main() 8.{
14. printf(“float = %lu\n”, sizeof(float));
15. printf(“double = %lu\n”, sizeof(double));
16. printf(“long double = %lu\n”, sizeof(long double));
17. return 0; 13.}

2.6.3 Caractere.

No C caractere representa uma letra somente que é o tipo char. O char é um tipo escalar porque cada letra pode ser representada por um número como na tabela ASCII. ➢ String em c não é um tipo primitivo. String é implementado como um vetor de char. Veremos esse tipo na próxima aula.

• Argumento de função. Indicamos e reforçamos que a função não recebe parâmetros.
• Ponteiros void. Ponteiro neutro de tipo.

2.7 Valores literais

Os valores literais em C são de tipagem estática e o compilador qualifica os literais de acordo com o conteúdo deles ou podemos indicar usando prefixos que o qualificam. Podemos descrever literais de tipos primitivos e literais de tipos derivados:

• Literal numérica inteira.
• Literal numérica ponto flutuantes.
• Literal caractere e string.

2.7.1 Literal numérica inteira.

Podemos representar valores inteiros em base decimal, octal e hexadecimal. Podemos também qualificar o inteiro como long, long long ou unsigned. // Números na base 10 0 , 1 , 3 ... 10 , 11 ... , 100 , - // Números na base octal inicia com 0 0, 01, 03, 07, 10, 011, ..., 100, - // Números na base hexadecimal inicia com 0x 0x0, 0x1, 0xa, 0xb, 0x10...0x100, -0x // Para representar long usamos um l ou L somo sufixo e long long usamos dois ll ou LL 1l, 3L, 07L, 0xal, 0x100LL, -0x100LL // Para representar unsigned usamos um u ou U como sufixo 1u, 3U, 07U, 0xau, 0x100U, -0x100U

2.7.2 Literal numérica ponto flutuantes.

Podemos representar literais ponto flutuante na notação decimal e na notação cientifica. Ambos as notações podem ser representadas na base decimal e hexadecimal. O qualificador padrão é signed float mas podemos mudar para float ou para long double. Para representar um numero ponto flutuante usamos o ponto para separar a parte inteira da fração. Se não tiver a parte fracionada podemos colocar “.0” ou apenas “.” // Números na base 10 0.5 , 5.0 , 5. //Números log double 0.5L, 5.0L, 5.L

// Podemos usar a notação cientifica 0.5e10, 5.0e2, 5.E // Números na base hexadecimal iniciamos com 0x 0x0.5p0 , 0x5.0p1 , 0x5.p

2.7.3 Literal caractere e string.

Literais caractere representam somente um caractere e representamos ele entre aspas simples “'”. A linguagem C trabalha com string sendo um conjunto de caractere como um vetor. Caracteres são escalares e podemos realizar todas as operações. // Letras 'a', 'b', 'c' // Podemos usar sequencias de escape ''', '\”', '?' // Podemos tambem usar código octal e hexadecimal '\0141', '\x61' // Literal string usamos aspas duplas “Bom dia”

2.7.4 Printf e os tipos de dados

Para cada tipo de dado primitivo existe uma diretiva do printf e podemos listar elas Letra Descrição i ou d Inteiro u Inteiro sem sinal hu short int lu long int llu long long int f double/float Lf long double

2.8 Exercícios

1. Complete os códigos abaixo: