Elementos de Linguagem C

Elementos de Linguagem C Parte I Elementos de linguagem C Parte I 1

Linguagem C Eficiência da execução O código gerado corre de forma eficiente, mesmo em processadores modestos, usados em sistemas embebidos Acesso ao hardware Manipulação directa da memória de dispositivos de I/O Portabilidade Disponibilidades de compiladores para numerosas arquitecturas APIs estabilizadas e suportadas em diversas plataformas Dependência da plataforma de execução O código compilado é especificamente gerado para uma determinada arquitectura Portar uma aplicação para outra plataforma implica, pelo menos, a recompilação do código Automatismo reduzido na gestão da memória O alojamento dinâmico é controlado explicitamente Não existe garbage collection nem outros de gestão automática da memória alojada dinamicamente Elementos de linguagem C Parte I 2

Introdução #include <stdio.h> int main(void){ printf("hello world!\n"); return 0; } Elementos de linguagem C Parte I 3

Variáveis Tipos básicos Inteiros char 8 bits com ou sem sinal armazenamento de caracteres int com sinal, dimensão natural da máquina típico 16 ou 32 bits Vírgula flutuante float precisão simples (típico 32 bits) double precisão dupla (típico 64 bits) Elementos de linguagem C Parte I 4

Variáveis Qualificadores Aplicáveis a inteiros signed [char int] valor com sinal unsigned [char int] valor sem sinal short [int] inteiro curto típico 16 bits long [int] inteiro longo típico 32 ou mais bits Aplicáveis a vírgula flutuante long double precisão extra (p. ex. 80 ou 96 bits) Outros, com significados diversos... Elementos de linguagem C Parte I 5

Variáveis - Declaração Formato tipo nome; Exemplos char c; /* Uma variável do tipo char */ int x, y; /* Duas variáveis do tipo int */ unsigned u; /* Uma variável do tipo int sem sinal */ short s; /* Uma variável do tipo short int */ long l; /* Uma variável do tipo long int */ double d; /* Uma variável do tipo double */ Elementos de linguagem C Parte I 6

Variáveis Localização Exterior às funções variáveis não automáticas Alojamento numa posição fixa da memória do sistema Interior às funções variáveis automáticas No interior da função ou de qualquer scope Alojamento gerido dinamicamente, suportado pelo stack do programa Resolução de nomes iguais considera a variável do scope corrente (não se recomenda o uso e abuso) Elementos de linguagem C Parte I 7

Variáveis Valor inicial Atribuído explicitamente Formato tipo nome = valor; Variáveis não automáticas Valor carregado no acto de lançamento do programa Variáveis automáticas Valor carregado sempre que se inicia a execução do respectivo scope Atribuído implicitamente Variáveis não automáticas valor 0 carregado no acto de lançamento do programa Variáveis automáticas indeterminado Não é carregado nenhum valor a memória mantém o valor, aleatório, que tem Elementos de linguagem C Parte I 8

Variáveis Exemplos int a; /* variável com o valor por omissão: 0 */ int b = 10; /* variável com o valor atribuído: 10 */ int main(void){ char c = 'a'; /* variável com valor inicial */ while(...){ char d; /* variável sem valor inicial conhecido */... if(...){ float f = 1.23e-4; /* variável iniciada cada vez que entrar no if */ }... }... } Elementos de linguagem C Parte I 9

Constantes Inteiros int sequência de dígitos 1234 10-20 long sufixo L ou l ou dígitos que excedem int 1234L 12345678l unsigned sufixo U ou u 1234U 5678u unsigned long combinação de sufixos 1234UL 5678ul Elementos de linguagem C Parte I 10

Constantes Inteiros Representação em octal prefixo 0 0123 (equivale a 83 em decimal) 0456 (equivale a 302 em decimal) Representação em hexadecimal prefixo 0x 0xffff (equivale a 65535 em decimal) 0x0a (equivale a 10 em decimal) Estas formas também admitem os sufixos U, u, L e l Elementos de linguagem C Parte I 11

Constantes Caracteres Valores inteiros gerados pelo compilador segundo a tabela ASCII 'a' 'b' 'A' 'B' '0' '1' '2' '3'... Sequências com significado especial '\b' '\t' '\n' '\r' '\\' '\'' '\ ' Valores expressos por dígitos em octal '\ooo' '\0' '\033' '\007' em hexadecimal '\xhh' '\x00' '\x1b' '\x07' Elementos de linguagem C Parte I 12

Constantes Strings Sequências de caracteres delimitadas por aspas "uma frase com diversas palavras" Armazenamento em memória sequência de bytes, com os códigos dos caracteres, terminada por um byte com o valor 0 ('\0'), inserido automaticamente Admite a inserção dos caracteres especiais na sequência "primeira linha \n segunda linha" Strings consecutivas formam uma única sequência em memória "uma frase com" " diversas palavras" é equivalente a "uma frase com diversas palavras" Elementos de linguagem C Parte I 13

Constantes Enumerados Definição de um conjunto de constantes com nome enum boolean { NO, YES }; Admite atribuição dos valores aos nomes enum escapes { BELL = '\a', BACKSPACE = '\b', TAB = '\t', NEWLINE = '\n', VTAB = '\v', RETURN = '\r' }; Admite atribuição de um valor, gerando os restantes em sequência enum months { JAN = 1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC }; Os nomes têm que ser distintos, mesmo em enumerados diferentes Os valores podem coincidir, em enumerados diferentes ou no mesmo Elementos de linguagem C Parte I 14

Operadores Aritméticos + - * / % Incremento e decremento ++ -- Relacionais e lógicos > >= < <= ==!= &&! Bit a bit & ^ << >> ~ Conversões de tipo Implícitas trunca ou expande adequadamente o número de bits Explícitas (cast) (tipo) expressão Afectação = += -= *= /= %= <<= >>= &= ^= = Expressão condicional (operador trenário) expr? expr1 : expr2 Elementos de linguagem C Parte I 15

Precedência e Associatividade Operators Associativity Comments ( ) [ ] ->. left to right! ~ ++ -- + - * & (type) sizeof right to left Unary operators * / % left to right Binary operators + - left to right Binary operators << >> left to right < <= > >= left to right ==!= left to right & left to right Bitwise and ^ left to right left to right && left to right left to right? : right to left = += -= *= /= %= &= ^= = <<= >>= right to left, left to right Elementos de linguagem C Parte I 16

Controlo Um Statemtent é Uma expressão seguida de ';' expression; Ou uma sequência de statements delimitada por chavetas {statement statement... statement} If-else if (expression) statement1 else statement2 Elementos de linguagem C Parte I 17

Controlo Else-if if (expression) statement else if (expression) statement else if (expression) statement else if (expression) statement else statement Elementos de linguagem C Parte I 18

Controlo Switch switch (expression) { case const-expr: statements case const-expr: statements default: statements } Elementos de linguagem C Parte I 19

Controlo While Do-while while (expression) statement do statement while (expression); Elementos de linguagem C Parte I 20

Controlo For for (expr1; expr2; expr3) statement Equivalente a: expr1; while (expr2) { statement expr3; } Elementos de linguagem C Parte I 21

Controlo Break Provoca a saída imediata do ciclo interior ou de um switch Continue Provoca a o fim da iteração corrente e regresso à condição de teste do ciclo interior No caso do for, executa a expressão de incremento Não se aplica a switch actua sobre o ciclo interior que contém o switch Elementos de linguagem C Parte I 22

Controlo Goto É útil quando não se pode aplicar break por exemplo, para quebrar um ciclo que não é o interior Funciona associado a uma label, com o formato nome: Elementos de linguagem C Parte I 23

Funções As funções são as entidades que contêm todo o código executável do programa O programa começa na função main, chamada a partir do módulo de arranque A função main chama outras funções para cumprir os objectivos do programa As funções recebem parâmetros e produzem valores de retorno Elementos de linguagem C Parte I 24

Funções Formato de escrita das funções tipo_retorno nome( parâmetros ) { statements } Formato da invocação... = nome( argumentos ); Se uma função não tiver parâmetros, a invocação tem igualmente os parêntesis operador de chamada... = nome(); Se o valor de retorno de uma função não existir ou não for útil, omite-se simplesmente a utilização nome( argumentos ); Elementos de linguagem C Parte I 25

Funções Parâmetros Os parâmetros são sempre passados por valor No caso de se passar uma variável, a função não pode modificá-la Se isso for necessário é a solução é passar o endereço ver adiante: ponteiros Se a função não tiver parâmetros, isso deve ser indicado pela palavra void tipo_retorno nome( void ){... Se não indicar nada, permite que a função aceite quaisquer parâmetros (não se recomenda, por ser propenso a erros) Elementos de linguagem C Parte I 26

Funções Retorno O valor de retorno pode ser de um tipo básico ou de outros, definidos pelo programador Existe um tipo por omissão, que é int (contudo, recomenda-se a indicação explícita) A emissão do valor de retorno faz-se com o statement return int add3int( int a, int b, int c ) { return a + b + c; } float add3float( float a, float b, float c ) { return a + b + c; } Se uma função não produzir valor de retorno, isso deve ser indicado pela palavra void e não é necessário o statement return void nome(parâmetros){... } Elementos de linguagem C Parte I 27

Comentários Sequências de caracteres ignoradas pelo compilador Início: /* Fim: */ Podem ocupar várias linhas de texto Elementos de linguagem C Parte I 28

struct A struct é uma estrutura de dados que suporta armazenamento não homogéneo (elementos cujo tipo pode ser diferente) Os elementos que formam uma struct são designados por campos ou membros e têm nome O tipo de cada campo pode ser qualquer, válido na linguagem, incluindo outras struct ou arrays É também admitida a definição de "bit fields" campos inteiros com um número arbitrário de bits O acesso aos campos de uma struct faz-se combinando o nome da variável que a contém com o nome do campo, ligados por um ponto As struct são alojadas assegurando o alinhamento de cada um dos seus campos a dimensão indicada pelo operador sizeof reflecte o alinhamento Elementos de linguagem C Parte I 29

struct definição e acesso struct st1{ int a; /* campo inteiro */ float b; /* campo float */ char c[10]; /* campo array de char */ int d:4; /* bit-fild de 4 bits */ }x; com o nome x */ /* a struct é alojada numa variável struct st1 y; /* outra struct idêntica com o nome y */... = x.a; /* acesso ao campo a de x */ y.c[n] =...; /* acesso ao campo c de y */ x = y; /* cópia integral de struct */ Elementos de linguagem C Parte I 30

struct declaração de tipo typedef struct st1{ /* Tag st1 opcional */ int a; /* campo inteiro */ float b; /* campo float */ char c[10]; /* campo array de char */ int d:4; /* bit-fild de 4 bits */ }S; /* S é, neste caso, um nome de tipo */ S x; /* uma struct S, alojada numa variável com o nome x */ S y; /* uma struct S, alojada numa variável com o nome y */... = x.a; /* acesso ao campo a de x */ y.c[n] =...; /* acesso ao campo c de y */ x = y; /* cópia integral de struct */ Elementos de linguagem C Parte I 31

Iniciação de variáveis struct... typedef struct st1{ /* Tag st1 opcional */ int a; float b; char c[10]; int d:4; }S; S x = {10, 1.234, ola, 2}; /* uma struct S, alojada numa variável com o nome x, com valores iniciais, todos explícitos*/ S y = {100, 12.34}; /* uma struct S, alojada numa variável com o nome y com valores iniciais, alguns explícitos e outros implícitos */ Elementos de linguagem C Parte I 32

Ponteiros Um ponteiro é uma variável que representa o endereço de outra variável Permite aceder a variáveis diversas, segundo as mudanças de valor do ponteiro A declaração de um ponteiro é indicada pelo operador unário * int * p1; /* ponteiro para variáveis do tipo int */ float * p2; /* ponteiro para variáveis do tipo float */ O acesso à variável apontada faz-se também com o operador * O endereço de uma variável pode obter-se com o operador unário & cujo tipo é de ponteiro para variáveis do tipo mencionado int a, b; int * p;... p = &a; /* obtém o endereço de a */ *p = 0; /* equivalente: a = 0; */ b = *p; /* equivalente: b = a; */ Elementos de linguagem C Parte I 33

Arrays O array é uma estrutura de dados que suporta o armazenamento homogéneo (colecção de elementos do mesmo tipo) O tipo dos elementos armazenados pode ser qualquer dos básicos ou outro, definido pelo programador O acesso aos elementos de um array é seleccionado por um índice Os valores válidos para o índice são de 0 a N-1, em que N é o número de elementos do array Declaração tipo nome_array[dimensão]; Utilização... = nome_array[índice]; nome_array[índice] =... Elementos de linguagem C Parte I 34

ponteiros e Arrays O nome de um array (sem os parêntesis rectos nem o índice) é um ponteiro para o primeiro elemento do array Considerando a declaração de um array: tipo a[dimensão]; *a =...; é exactamente o mesmo que a[0] =...; O acesso a elementos através de um ponteiro pode ser feito indiferentemente com o operador * ou com o operador [] *p =...; é exactamente o mesmo que p[0] =...; Aritmética de ponteiros: Se o ponteiro p contém o endereço do elemento i de um array, a expressão p+n representa o endereço do elemento i+n *(p+n) =...; é exactamente o mesmo que p[n] =...; O cálculo do endereço apontado é feito pelo compilador, de acordo com a dimensão do elemento apontado A aritmética de ponteiros só é válida para aceder a elementos de um mesmo array e não a quaisquer variáveis declaradas em separado Elementos de linguagem C Parte I 35

ponteiros e Arrays Na declaração de parâmetros das funções pode ser indiferentemente usada a notação de ponteiro ou de array int strlen(char * s){... é exactamente o mesmo que int strlen(char s[]){... em ambos os casos, o acesso aos dados representados pelo parâmetro pode ser feito com a notação de ponteiro ou de array... = *s; ou... = s[...]; Elementos de linguagem C Parte I 36

ponteiros e Arrays A declaração de variáveis ponteiro ou array tem significados diferentes A declaração de um array reserva espaço em memória para os elementos que ele irá conter A declaração de um ponteiro só reserva espaço para o próprio ponteiro e não para quaisquer dados apontados Um ponteiro só tem significado válido depois de afectado com o endereço de uma variável adequadamente alojada A afectação de um ponteiro pode ser realizada na declaração, na forma de valor inicial int a[...]; int b; int *p1 = a; int *p2 = &b; Elementos de linguagem C Parte I 37

Arrays Iniciação Na declaração de um array pode ser feita a sua iniciação Se a dimensão for omitida, o compilador calcula Se for indicada, preenche restantes com 0 Se a dimensão indicada for insuficiente, é erro int a[] = {1, 2, 3}; /* array de 3 int: valores 1, 2 e 3 */ int b[10] = {4, 5, 6}; /* array de 10 int: os primeiros valem 4, 5, e 6; os restantes valem 0 */ char c[] = "ola"; /* array de 4 char: 'o', 'l', 'a' e '\0' */ char d[3] = "ola"; /* erro!, não cabe o terminador '\0' */ A declaração de ponteiros iniciados como se fossem arrays tem significado diferente int *p = {1, 2, 3}; /* ponteiro para int, iniciado com o endereço de uma área de constantes com os valores 1, 2 e 3 */ char *p = "ola"; /* ponteiro para char, iniciado com o endereço de uma área de constantes com os valores 'o', 'l', 'a' e '\0' */ Elementos de linguagem C Parte I 38

Arrays multidimensionais Podem definir-se arrays de arrays int a[10][20]; /* a é um array de 10 elementos, sendo cada um deles um array de 20 inteiros */ char b[10][5][20]; /* b é um array de 10 elementos, sendo cada um deles um array de 5 elementos que são arrays de 20 char */ Se forem definidos parâmetros de funções como arrays multidimensionais, é necessários especificar as dimensões, excepto a primeira void func(char x[][5][20]); /* O parâmetro x é o endereço de um array cujos elementos são arrays de 5 elementos, sendo cada um deles um array de 20 char */ Elementos de linguagem C Parte I 39

Argumentos de linha de comando Está previsto o acesso argumentos introduzidos na linha de comando pelo utilizador Cada argumento é uma palavra O parâmetro argc indica o número de palavras, incluindo o nome do executável O parâmetro argv representa o endereço de um array de ponteiros para as localizações, em memória, das palavras Exemplo: mostrar todos os argumentos int main(int argc, char * argv[]){ int i; for(i = 0; i!= argc; ++i){ printf("%s ", argv[i]); } } Elementos de linguagem C Parte I 40

Campos ponteiro para struct Em estruturas de dados como listas e árvores, declaram-se campos ponteiros para a própria ou outra struct typedef struct st{ struct st *p; /* ponteiro para a própria struct usa a tag st */ int a; /* outros campos... */ int b; }X; X x1, x2; /* duas variáveis deste tipo de struct*/... x1.p = &x2; /* acesso ao campo ponteiro Elementos de linguagem C Parte I 41

Arrays e iniciação de struct Podem definir-se arrays de struct typedef struct stx{ int a; int b; } X; X ax[100];... ax[i].a =...; Podem preencher-se com valores iniciais X x = {10, 20}; /* x.a = 10, x.b = 20 X ax[] = {{10, 20}, {11, 21}, {12, 22}}; /* array de três estruturas iniciadas. As chavetas interiores são opcionais, para legibilidade Elementos de linguagem C Parte I 42

Ponteiros para struct typedef struct stx{ int a; int b; } X; X ax[100]; X *p;... p = ax; /* ou, por ex.: p = &ax[i]; equivalente a: p = ax+i; */... (*p).a =...; /* acesso ao campo a da struct apontada, operadores * e. */ p->a =...; /* forma de escrita equivalente, com o operador -> */ Elementos de linguagem C Parte I 43

Struct em parâmetros de funções Um parâmetro struct implica a passagem por valor, isto é, a cópia do conteúdo da struct typedef struct{...} X; tipo_ret nome_func(x x){... Se não se pretender a cópia, define-se o parâmetro de modo a passar um ponteiro para a struct tipo_ret nome_func(x *xp){... Ou define-se o tipo de dados com a struct encapsulada num array de um só elemento (um parâmetro array é um ponteiro) typedef struct{...}x[1]; tipo_ret nome_func(x x){... Elementos de linguagem C Parte I 44

Struct em retorno de funções O tipo de retorno de uma função pode ser struct O espaço para suportar este retorno é gerido pela função chamadora A função chamada declara, normalmente, uma instância da struct para usar em return typedef struct {...}X; X func(parâmetros){... X x; x.campo =...;... return x; } Elementos de linguagem C Parte I 45

Struct e Union A declaração de variáveis union é idêntica à de struct A diferença está no alojamento dos campos: todos têm o mesmo endereço A union é uma forma de aceder ao mesmo espaço de memória com tipos diferentes A dimensão total da union é a dimensão do maior dos seus campos Elementos de linguagem C Parte I 46

Funções com lista de parâmetros variável A linguagem C suporta funções com parâmetros variáveis, indicados por '...' A mesma função, em utilizações diferentes, recebe um número de parâmetros diferente ou com tipos diferentes A função recebe, tipicamente, um parâmetro fixo que lhe permite identificar os variáveis Exemplo: printf(char *fmt,...); int i; char car; char str[] = "frase";... printf("%d\n", i); printf("%c\n", car); printf("%c %d %s\n", car, i, str); Elementos de linguagem C Parte I 47

Funções com lista de parâmetros variável As funções definidas pelo programador também podem ter lista de parâmetros variável Neste caso o acesso aos parâmetros variáveis pode se feito usando um ponteiro iniciado a partir do último parâmetro fixo int addintlist(int count,...){ int *p = &count + 1; int res = 0; while(count--){ res += *(p++); } return res; } Elementos de linguagem C Parte I 48

Parâmetros variáveis stdarg.h Uma forma sistemática e flexível de acesso a parâmetros variáveis está disponível no ficheiro stdarg.h, com o tipo va_list e macros associadas int addintlist(int count,...){ va_list ap; int res = 0; va_start(ap, count); while(count--){ res += va_arg(ap, int); } va_end(ap); return res; } Elementos de linguagem C Parte I 49

ponteiros para função A definição de ponteiros para funções implica a especificação dos parâmetros e retorno da função apontada Exemplos: Declaração de um ponteiro para função sem parâmetros nem valor de retorno void (*fp)(void); Declaração de um ponteiro para função com dois parâmetros e retorno do tipo int int (*fp)(int, int); Definição de tipos e declaração de ponteiros com esses tipos typedef void (*fpt1)(void); typedef int (*fpt2)(int, int); fpt1 fp1; fpt2 fp2; Elementos de linguagem C Parte I 50

ponteiros para função A utilização do ponteiro para chamar a função é infdicada pelos parêntesis curvos operador de chamada que contêm os parâmetros, se existirem Exemplos void (*fp)(void); void f(void){...}... fp = f; fp(); void(*fpa[10])(void) = {f1, f2,...};... for(...;...;...){ fpa[i](); } Elementos de linguagem C Parte I 51

ponteiros descomprometidos void * p; p aponta um tipo indefinido p é compatível com qualquer outro ponteiro void * p; int * q; p = q; q = p; a mudança do tipo de ponteiro, de ou para void *, não altera o endereço apontado É frequente como parâmetro ou retorno de funções Exemplos: void *malloc(size_t size); void free(void *p); Elementos de linguagem C Parte I 52