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 */

   /*
     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\)

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, variá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;
}

Expressões

• Expressões são constituidas por variáveis, constantes e operadores
• A linguagem C inclui operadores para:
  • aritmética (+, -, *, /)
  • comparações
  • operações lógicas
  • atribuição
  • pré- e pós-incremento e decremento

Operadores aritméticos

• Operadores binários (sobre dois valores)

• Operadores unários (sobre um valor)

Operadores aritméticos unários

• Necessitam apenas de um operando; exemplos:

    i = +1;
    j = -i;

• O operador + unário não tem qualquer efeito; é usado principalmente para sinalizar constantes positivas

Operadores aritméticos binários

• +, *, e / permitem misturar operandos inteiros e vírgula-flutuante
• Quando combinamos operandos int e float, o resultado é um float
  • ex: 2+0.5 dá 2.5; 3.5/2 dá 1.75

Divisão inteira

• Se os operandos são inteiros, o resultado de / é o quociente:
  • 3/4 dá 0
  • 10/3 dá 3
• i%j é o resto da divisão inteira de i por j:
  • 10%3 dá 1
  • 12%4 dá 0

Cuidados com / e %

• Ambos os operandos de % devem ser inteiros
• Se o lado direito de / ou % for 0, o resultado é indefinido (divisão por zero)
• Se o lado direito de % for negativo:
  • em C99: i%j tem o mesmo sinal que i
  • em C89/C90: depende da implementação

Precedência de operadores

• Como interpretar i+j*k?
  • “somar i com o resultado de multiplicar j por k”
  • “somar i com j e multiplicar o resultado por k”
• Podemos usar parêntesis para tornar o sentido não ambíguo:
  • i+(j*k) ou (i+j)*k
• Na ausência de parêntesis: a precedência entre operadores desambigua o significado

Precedência de operadores

1. Primeiro é avaliados + e - unários
2. Depois *, /, %
3. Por fim + e - binários

Exemplos

Associatividade de operadores

• A associatividade define como interpretar dois ou mais operadores com igual precedência
• Os operadores binários (+, -, *, /, %) associam à esquerda
• Os operadores unários associam à direita

Exemplos

Atribuição simples

• A atribuição \(var = expr\) calcula o valor de \(expr\) e copia-o para a variável \(var\)
• O lado direito pode ser uma constante, uma variável ou uma expressão complexa

    i = 5;            /* valor de i: 5  */
    j = i;            /* valor de j: 5  */
    k = 10 * i + j;   /* valor de k: 55 */

Atribuição simples (cont.)

Se a variável e expressão não forem do mesmo tipo dá-se uma conversão implícita de tipos.

   int i;
   float f;
    
   i = 72.99;   // valor de i: 72 
   f = 136;     // valor de f: 136.0 

Atribuições são expressões

• Na linguagem C uma atribuição é também uma expressão
• O resultado de \(var = expr\) é o valor que foi atribuido

Exemplo:

int i, j, k;
i = 1;
k = 1 + (j = i);
   // j: 1, k: 2

Cuidado: usar atribuições no meio de expressões pode dificultar a compreensão de programas

Atribuições em sequência

Podemos atribuir um mesmo valor a várias variáveis:

i = j = k = 0;

Como a atribuição associa à direita, isto é equivalente a:

i = (j = (k = 0));

Valores esquerdos (Lvalues)

• O lado esquerdo de uma atribuição corresponde a um local na memória (“lvalue”)
• Uma variável é um lvalue, mas as constantes ou expressões compostas não são
• O compilador assinala erro numa atribuição com lado esquerdo inválido: “invalid lvalue in assigment”

i = 12;    // OK: i é um lvalue
12 = i;    // erro: 12 não é um lvalue
1+j = 12;  // erro: 1+j não é um lvalue

Atribuição composta

É frequente atribuir a uma variável um novo valor que depende do seu valor atual.

Exemplo:

i = i + 2;

Nestes casos podemos usar uma atribuição composta:

i += 2;

Operadores de atribuição composta

\(v\) += \(e\)

adicionar \(e\) de \(v\), guardando o resultado em \(v\)

\(v\) -= \(e\)

subtrair \(e\) a \(v\), guardando o resultado em \(v\)

\(v\) *= \(e\)

multiplicar \(e\) por \(v\), guardando o resultado em \(v\)

\(v\) /= \(e\)

dividir \(v\) por \(e\), guardando o resultado em \(v\)

\(v\) %= \(e\)

calcular o resto de divisão de \(v\) por \(e\), guardando o resultado em \(v\)

Incremento e decremento

É frequente somar ou subtrair uma variável inteira de uma unidade.

i = i + 1;
j = j - 1;

Também aqui podemos usar uma atribuição composta:

i += 1;
j -= 1;

Em alternativa, podemos usar operadores de incremento ou decremento.

Incremento e decremento (cont.)

• A linguagem C tem operadores especiais para incremento e decremento
• Podem ser usados de forma prefixa (++i ou --i) ou pósfixa (i++ ou i--)

++i;        // equivalente a i = i + 1
--j;        // equivalente a j = j - 1

Pré- e pós-incremento

++i modifica a variável i (incrementa de uma unidade) e dá o valor resultante.

i = 1;
printf("%d\n", ++i);  // imprime 2
printf("%d\n", i);    // imprime 2

i++ dá o valor atual de i e depois modifica a variável i (incrementa de 1 unidade).

i = 1;
printf("%d\n", i++);  // imprime 1
printf("%d\n", i);    // imprime 2

Pré- e pós-incremento

• ++i incrementa imediatamente, enquanto i++ incrementa mais tarde
• O standard de C não especifica exatamente quando acontece o pós-incremento, mas é seguro assumir que i será incrementada antes da próxima instrução

Pré- e pós-decremento

O operador de decremento comporta-se de forma análoga ao de incremento:

i = 1;
printf("%d\n", --i);  // imprime 0
printf("%d\n", i);    // imprime 0
i = 1;
printf("%d\n", i--);  // imprime 1
printf("%d\n", i);    // imprime 0

Incremento e decremento

Pode ser difícil seguir o efeito de múltiplos ++ ou -- em várias variáveis numa mesma expressão:

i = 1;
j = 2;
k = ++i + j++;
 // i: 2, j: 3, k: 4

i = 1;
j = 2;
k = i++ + j++;
 // i: 2, j: 3, k: 3

Recomendação: evite expressões com mútiplos incrementos.

Ordem de avaliação

a = 5;
c = (b = a + 2) - (a = 1);

Qual é o valor final de c?

Ordem de avaliação

• O padrão da linguagem C não garante uma ordem para avaliação de subexpressões
  • e.g.: ao calcular (a + b) * (c - d) não sabemos se será calculado primeiro (a + b) ou (c - d)
• Para a maior parte das expressões, a ordem de avaliação não afeta o resultado
• Contudo: pode afetar o resultado se as sub-expressões modificarem variáveis:
  • e.g.: (b = a + 2) - (a = 1)

Outro exemplo

i = 2;
j = i * i++;

O resultado final de j depende da ordem de avaliação da multiplicação (4 ou 6).

Comportamento indefinido

• Expressões como c=(b=a+2)-(a=1); ou j=i*i++; têm comportamento indefinido:
  • podem dar resultado diferentes com compiladores diferentes
  • podem não executar, terminar abruptamente ou dar resultados errados
• Devemos sempre evitar expressões com comportamento indefinido
• O compilador ajuda a detetar alguns comportamento indefinidos com a opção de compilação -Wall:

       gcc -Wall -o programa programa.c

Comportamento indefinido

Re-escrever o primeiro exemplo para evitar comportamento indefinido:

a = 5;
b = a + 2;
a = 1;
c = b - a;

Desta forma o resultado final de c é sempre 6.