Programas

• Programas C são ficheiros de texto
• Compostos usando um editor de texto
  (exemplos: GNU Emacs, Atom, ...)
• Convenção: nome de ficheiro termina com extensão .c (letra minúscula)

#include <stdio.h>

int main(void)
{
  printf("To C or not to C, ");
  printf("that is the question.\n");
  return 0;
}

Execução

Para ser executado, um programa em C tem primeiro de ser traduzido para código-máquina.

A tradução é efetuada por programa compilador.

Nestas aulas: vamos usar o GCC (GNU Compiler Collection).

Fases de tradução

Pré-processamento

o pré-processador interpreta diretivas (linhas que começam por #)

Compilação

o compilador traduz o código C para código-máquina

Ligação

o ligador (linker) combina o código-máquina gerado com as bibliotecas necessárias

Em sistemas GNU/Linux: o pré-processador, compilador e ligador são executados em sequência pelo comando gcc.

Compilar, ligar e executar

Invocamos o compilador usando o interpretador de comandos Linux (shell):

$  gcc -o hello hello.c 

Produz um ficheiro hello que podemos executar:

$ ./hello
To C or not to C, that is the question.

Estrutura de programas simples

directivas

int main(void)
{ 
    instruções
}

Directivas

• Um directiva é indicada por uma linha começada por #; e.g.:

   #include <stdio.h>

• A linguagem C inclui ficheiros header com declarações de bibliotecas
• stdio.h contém as definições associadas a entrada/saida
• Exemplo: printf está declarado neste header

Funções

• Uma função agrupa uma sequência de instruções com um nome
• Um implementação da linguagem C disponibiliza várias bibliotecas com funções pre-definidas
• O resultado duma função é especificado com a instrução return

Função main

• Um programa completo deve definir uma função main que é executada quando o programa inicia
• O valor retornado de main representa o código de erro para o sistema operativo
• Retornar zero significa que o programa terminou corretamente

   int main(void)
   {
      ....
      return 0;
   }

• Em C99: podemos omitir o return (equivale a retornar 0)

Instruções

• O corpo de uma função é uma sequência de instruções

  printf("To C or not to C, ");
  printf("that is the question.\n");
  return 0;

• Este exemplo usa apenas dois tipos de instruções: chamadas da função printf e return
• A chamada printf("...") imprimem o texto entre aspas na saida-padrão (terminal)
• Imprime a seguinte mensagem:

   To C or not to C, that is the question.

Instruções (cont.)

• Cada instrução termina com ponto-e-vírgula (;)
• Uma instrução pode ser dividida em várias linhas:

  printf(
     "To C or not to C, "
  );

• Também podemos escrever várias instruções numa linha:

  printf("To C or "); printf("not to C, ");

• As directivas ocupam normalmente apenas uma linha: não necessitam de ponto-e-vígula

Comentários

• Um comentário começa com /* e termina com */
• Comentários podem ocorrer em linhas separadas ou no meio de linhas com código
• Podem extender-se por várias linhas

   /* Isto é um comentário */

   /*
     Autor:   Pedro Vasconcelos
     Ficheiro: hello.c
     Programa: Imprime uma mensagem de exemplo
   */

Comentários (cont.)

Atenção: esquecer de fechar um comentário pode fazer com que o compilador ignore parte do programa.

   printf("To be ");    /* comentário aberto
   printf("or not to be; ");   /* fechado */
   printf("that is the question.\n");

Comentários (cont.)

• Em C99, podemos também escrever comentários de uma só linha:

   // Isto é um comentário

• Começa com // e termina no final da linha
• Mais sucinto para comentários curtos
• Evita o risco de esquecer fechar o comentário

Variáveis e atribuições

• Os programas em C efectuam computação modificando valores em memória
• Os locais para guardar valores são designados usando variáveis

Tipos

• As variáveis em C têm associado um tipo
• Tipos numéricos básicos: int e float
• Uma variável de tipo int pode guardar valores inteiros positivos e negativos; e.g.:
  • 0 1 -23 397
• Os valores mínimo e máximo de int dependem da implementação; e.g.:
  • o GCC em Intel x86/x64 usa 32-bits
  • inteiros de \(-2^{31}\) a \(+2^{31}-1\)
    (ver as aulas de IC...)

Tipos (cont.)

• Uma variável float guarda valores de vírgula-flutuante com precisão simples
• Pode representar valores fracionários:
  • 0.0253 -1.25 123.555
• Também valores de magnitudes muito grandes ou pequenas (aproximadamente entre \(10^{-38}\) e \(10^{+38}\))
• Desvantagens:
  • operações mais lentas do que com inteiros
  • erros de arredondamento

Declarações

As variáveis têm de ser declaradas antes do uso:

   int altura;
   float raio;

Podemos declarar múltiplas variáveis do mesmo tipo duma só vez:

   int altura, largura, profundidade;
   float raio, massa;

Declarações

Até C89: todas as declarações têm de ocorrer antes das instruções.

int main(void) {
   /* declarações de variáveis */
   int altura, largura;
   float raio;

   /* seguem-se instruções */
   ...
}

Em C99: declarações e instruções podem ser misturadas (desde que a declaração ocorra antes do uso).

Atribuição

Podemos definir ou modificar o valor de uma variável usando uma atribuição.

   int altura;   // declaração
   altura = 8;   // atribuição

• A atribuição têm de ocorrer depois da declaração
• Neste caso: atribuimos a constante 8 à variável altura

Atribuição (cont.)

No lado direito duma atribuição podemos usar expressões e.g.
constantes, varáveis e operações.

   int altura, largura, area;
   altura = 8;
   largura = 3;
   area = altura * largura;
       // area é 24

Exemplo

Um programa para calcular o volume \(V\) de uma caixa retangular.

Exemplo:

\[ V = 11 \text{cm} \times 5 \text{cm} \times 6 \text{cm} = 330 \text{cm}^3 \]

volume.c

#include <stdio.h>

int main(void) {
   int l, w, h, v;   // dimensões e volume

   l = 11;    // comprimento
   w = 5;     // largura
   h = 6;     // altura
   v = l*w*h; // cálculo do volume

   printf("LxWxH: %d*%d*%d (cm)\n", l,w,h);
   printf("Volume: %d (cm^3)\n", v);
   return 0;
}

Imprimir valores

Podemos usar a função de bibloteca printf para imprimir valores das variáveis. Exemplo:

   int alt;
   alt = 6;
   printf("Altura: %d cm\n", alt);

Imprime o texto:

   Altura: 6 cm

%d é um campo que é substituido pelo valor duma variável inteira em decimal.

Imprimir valores (cont.)

Para valores float usamos o campo %f.

   float custo;
   custo = 123.45;
   printf("Custo: EUR %f\n", custo);

Resultado:

   Custo: EUR 123.449997

• Não é possível representar 123.45 de forma exata como float!
• %f apresenta o resultado arrendondado a 6 casas decimais

Imprimir valores (cont.)

Para forçar formatação com \(n\) casas decimais usamos %\(.n\)f:

Exemplo:

   printf("Custo: EUR %.2f\n", custo);

Resultado:

   Custo: EUR 123.45

Imprimir valores (cont.)

Podemos formatar vários valores num só printf:

   printf("Altura: %d cm; Custo: EUR %.2f\n",
          alt, custo);

Atenção:

• especificar o mesmo número de campos do que argumentos
• usar campos corretos para cada tipo (%d para int, %f para float)

Ler valores

• A função de biblioteca scanf é usada para ler valores da entrada-padrão (teclado)
• Tal como printf o 1º argumento é o formato dos dados
• Exemplo: ler um valor inteiro e guardar o resultado na variável n

   int n;
   scanf("%d", &n);

• É necessário colocar o sinal & antes do nome da variável a ler (mais tarde veremos porquê)

Ler valores (cont.)

Para ler um float não necessitamos de especificar casas decimais.

   float x;
   scanf("%f", &x);

Funciona com ou sem casas decimais na entrada; exemplos:

   123
   123.4
   123.4567

Exemplo revisto

Vamos alterar o programa de exemplo anterior para ler as dimensões da caixa.

volume.c revisto

#include <stdio.h>

int main(void) {
   int l, w, h, v;   // dimensões e volume

   printf("L=?"); scanf("%d", &l);
   printf("W=?"); scanf("%d", &w);
   printf("H=?"); scanf("%d", &h);
   v = l*w*h; // cálculo do volume

   printf("LxWxH: %d*%d*%d (cm)\n", l,w,h);
   printf("Volume: %d (cm^3)\n", v);
   return 0;
}

Inicializações

• Variáveis em C não são inicializadas automaticamente
• Uma variável a que não atribuimos um valor diz-se não-inicializada:

   int x, y;
   y = x + 1;  // variável x não-inicializada

• O resultado de usar variáveis não-inicializadas é imprevisível:
  • valores diferentes em cada execução;
  • terminar execução com erro (crash)
• O compilador gcc pode detetar variáveis não-inicializadas usando a opção -Wall

Inicializações (cont.)

• Podemos inicializar variáveis diretamente na declaração:

   int alt = 8;

• Também para múltiplas variáveis:

   int alt = 8, larg = 5, comp = 11;

• Cada variável necessita do seu inicializador:

   int alt, larg, comp = 11;
     // só inicializa uma variável (comp)

Identificadores

• Os nomes de variáveis, funções e outras entidades são identificadores
• Podem conter letras, algarismos e sublinhado mas devem começar por letras ou sublinhado
• Apenas letras não acentuadas (i.e. ASCII)

Exemplos válidos:

   times10   get_Next_Char   _done

Exemplos inválidos:

   10times   get-Next-Char   máximo

Idetificadores (cont.)

• Maiúsculas e minúsculas são distintas; por exemplo

   get_next_char
   get_next_Char
   get_Next_Char

são identificadores diferentes (seria confuso usá-los num mesmo programa...).

• Não há limite definido para comprimento dos identificadores

Palavras reservadas

Não podemos usar as seguintes palavras reservadas como identificadores.

auto      enum      restrict   unsigned
break     extern    return     void
case      float     short      volatile
char      for       signed     while
const     goto      sizeof     _Bool
continue  if        static     _Complex
default   inline    struct     _Imaginary
do        int       switch
double    long      typedef
else      register  union

Definir constantes

• É por vezes necessário usar constantes ou parâmetros
• Constantes espalhadas pelo programa podem obfuscar o sentido
• Em vez disso: podemos usar directivas #define para definir macros

#define INCHES_PER_METER   39.3701
   /* factor de conversão:
      polegadas por cada metro */

• Convenção: nomes de constantes em maísculas

Pre-processamento

O pré-processador substitui as macros textualmente.

Exemplo:

   inches = meters * INCHES_PER_METER;

após processamento fica:

   inches = meters * 39.3701;

Exemplo

Um programa para calcular a área de uma circunferência.

A área de uma círcunferência de raio \(r\) é \[ A = \pi r^2 \] (onde \(\pi\) é a constante \(3.14159\ldots\)).

area.c

#include <stdio.h>

#define PI 3.14159 

int main(void) {
   float raio, area;
   printf("Raio da circunferência?");
   scanf("%f", &raio);
   area = PI * raio * raio;
   printf("Área: %f\n", area);
   return 0;
}

Estrutura de programas

Um programa em C é uma sequência de símbolos ("tokens"):

• identificadores
• palavras reservadas
• operadores
• pontuação
• constantes
• cadeias de carateres literais

Estrutura de programas

Exemplo: a instrução

   printf("Área: %f\n", area);

contém sete símbolos:

Layout de programas

• Os espaços entre símbolos não são normalmente importantes
• Podemos mesmo omitir espaços (exceto quando dessa forma dois símbolos distintos se fundem)
• Contudo, isto dificulta a legibilidade dos programas

#include <stdio.h>
#define PI 3.14159 
int main(void) {float raio,area;printf(
"Raio da circunferência?");scanf("%f",&raio);
area=PI*raio*raio;printf("Área: %f\n",area);
return 0;}

Layout de programas

Devemos usar espaços, tabulações e mudança de linha para aumentar a legibilidade do programa:

• inserir espaços após vírgulas ou entre operadores;
• usar tabulações para alinhar instruções;
• usar linhas em branco para separar visualmente blocos de código;
• inserir comentários entre linhas (ou mesmo no meio de uma linha).

Salientar a sintaxe

• Os editores de texto têm modos especiais para linguagens de programação
• Entre outras coisas salientam automaticamente símbolos com cores e/ou estilos
• Auxiliam a leitura e escrita de programas

Exemplo

#include <stdio.h>

#define PI 3.14159

int main(void) {
   float raio, area;

   printf("Raio da circunferência?");
   scanf("%f", &raio); 
   area = PI * raio * raio;
        // calcular a área
   printf("Área: %f\n", area);
   return 0;
}