Unesp UNIVERSIDADE ESTADUAL PAULISTA CAMPUS DE GUARATINGUETÁ FACULDADE DE ENGENHARIA Introdução à Programação em C Linguagem C: Conceitos Básicos Prof. Dr. G. J. de Sena Edição: 2011
Capítulo 2 Linguagem C: Conceitos Básicos 2.1. Estrutura de um Programa em C Um programa C é constituído por uma ou mais funções, devendo possuir uma função de abertura, a saber, a função main(). Elementos de uma função: (a) Cabeçalho (header): da forma nome(<argumentos>); Onde os argumentos são opcionais. (b) Lista de declarações dos argumentos. (c) Bloco de instruções. Pontos a observar na codificação de programas em C: Caracter(es) Significado { e } Delimitadores para blocos de instruções. ; Designa o final de uma instrução elementar. /* e */ Delimitadores de comentários: o texto delimitado pelos pares /* e */ é um comentário, sendo ignorado pelo compilador. // Designa o início de um comentário: o texto que segue o par // e continua até o final da linha é um comentário. Exemplo 1 : Programa para cálculo da área de um circulo. Codificação em C: // Calculo da área de um círculo // Programador: Sena Ano: 2010 #include <stdio.h> int main(void) { /* Declarações de Variáveis */ float raio, area; /* entrada do raio*/ 1 O aluno não deve se preocupar neste ponto em entender todos os programas apresentados, mas apenas em ter uma visão geral da linguagem. Os comandos e estruturas apresentados nestes exemplos iniciais serão explicados de modo detalhado mais adiante durante o curso.
} printf ("Digite o valor do raio: "); scanf ("%f", &raio); /* processamento: calculo da área*/ area = 3.141593 * raio * raio; /* saída da área */ printf ( "Area = %f", area ); /* pausa p/ mostrar resultado */ system("pause"); Tela de execução: Note-se que a seqüência de escape, \n, pode ser inserida no comando de saída, para forçar o avanço para uma nova linha: printf ( "\narea = %f \n", area ); Tela de execução: A instrução #include antes do cabeçalho da função é uma instrução para o préprocessador da linguagem, sendo tratada antes do processamento do programa. Estas instruções se referem a arquivos especiais que devem ser incluídos e que contêm informações especificas necessárias para a utilização de funções de biblioteca, providas pelo processador da linguagem. A seguir são mostrados exemplos de instruções #include: #include <stdio.h> #include <math.h> #include <stdlib.h> Programa para cálculo da área de um círculo, utilizando a função pow (de math.h) para calcular o quadrado do raio. // Calculo da área de um círculo utilizando a função // pow(x,y), que calcula e retorna o valor de x^y // Programador: Sena Ano: 2010 #include <stdio.h>
#include <math.h> int main(void) { /* Declarações de Variáveis */ float raio, area; /* entrada do raio*/ printf ("Digite o valor do raio: "); scanf ("%f", &raio); /* processamento: calculo da área*/ area = 3.141593 * pow(raio,2); // pow(raio,2) = raio^2 /* saída da área */ printf ( "\narea = %f \n", area ); // \n: avança próx. linha /* pausa p/ mostrar resultado */ system("pause"); } Tela de execução: Outras observações relativas à codificação de programas em C: (a) A linguagem C é sensível ao caixa, ou seja, letras maiúsculas e minúsculas são consideradas distintas. Assim, Area e area são identificadores distintos em C. (b) Observe-se, na estruturação de um programa em C, a presença de um recuo ( endentamento ), antes da codificação dos comandos e declarações no bloco de instruções: os comandos e declarações são codificados com um pequeno deslocamento para a direita. (c) Note-se a presença de comentários objetivando documentar o código do programa. Programa para cálculo da área de um círculo, utilizando uma função adicionalmente à função main(). // Calculo da área de um círculo, om a utilização de // uma função implementada pelo programador // Programador: Sena Ano: 2010 # include <stdio.h> # include <math.h> # define PI 3.141593 // definição da constante PI // função principal int main (void) { // declaração de variáveis e funções float raio, area; float processa (float raio); // função para calculo da área // entrada de dados printf("\n\traio? "); // seqüência \t: tabulação scanf ("%f", &raio);
/* Estrutura Condicional: a área só é calculada para um valor de raio válido (> 0) */ if (raio < 0) ; // não faz nada: comando "vazio" else // raio válido { area = processa (raio); // chama função printf("\n\narea = %f\n", area); // saida área } system("pause"); // pausa p/ visualização resultado } // função para cálculo da área float processa (float r) { float a; a = PI * pow(r,2); // calcula return(a); // retorna o valor calculado } Note-se a utilização de uma estrutura condicional para verificar se o raio fornecido é válido (> 0). Tela de execução: Modificação do programa do exemplo anterior, para cálculo da área de vários círculos. // Calculo da área de vários círculos // Programador: Sena Ano: 2010 # include <stdio.h> # include <math.h> # define PI 3.141593 // definição da constante PI // função principal int main (void) { // declaração de variáveis e funções float raio, area; int cont, n ; // contador (cont) e nro de círculos (n) float processa (float raio); // entrada de dados printf ("\nquantos circulos? "); scanf ("%d", &n); // processamento for (cont = 1 ; cont <= n ; ++ cont) /* Repetição */ { /* entrada do raio */ printf("\n\tcirculo %d: raio? ", cont); scanf ("%f", &raio); /* Laço Condicional */ if (raio < 0); // comando "vazio"
else // raio válido { area = processa (raio); // chama função printf("\n\narea = %f\n", area); // saida área } } system("pause"); // pausa p/ visualização resultado } // função para cálculo da área float processa (float r) { float a; a = PI * pow(r,2); // calcula return(a); // retorna o valor calculado } Tela de execução: 2.2. Fundamentos 2.2.1. Conjunto de Caracteres Letras: A... Z, a... z. Dígitos: 0... 9. Caracteres Especiais:! * + \ " < # ( = { > % ) ~ ; } / ^ - [ :,? & _ ]. b Seqüências de Escape : \b, \n (para nova linha) e \t (para tabulação). 2.2.2. Identificadores e Palavras Chave
Um identificador é um nome dado a elementos de um programa tais como variáveis, funções e matrizes. Formação: letras, dígitos e o caractere _ (considerado como letra). O primeiro caractere deve ser necessariamente alfabético (sendo permitido também o _). Exemplos válidos: X y24 TaxaDeJuros _saldo TABELA_EXEMPLO Xf Soma Exemplos não válidos: 4th "nome" soma-1 juro final raio??raio O comprimento permitido para um identificador é de, normalmente, até 31 caracteres 2 (de acordo com o padrão ANSI: American National Standaros Institute, que é o comitê responsável pela padronização de linguagens). Palavras-Chaves (reservadas): não devem ser utilizadas como identificadores em um programa. Alguns exemplos de palavras reservadas da Linguagem C são apresentados na tabela a seguir. auto extern sizeof break float static case for struct char goto switch const if typedef default long union do register unsigned double return void else short volatile enum signed while 2.2.3. Tipos de Dados Básicos Os tipos de dados básicos da Linguagem C são os apresentados na tabela a seguir. A coluna Memória especifica a quantidade de memória necessária, em bytes, para armazenar um valor de um determinado tipo. Tipo Descrição Memória int Valor Inteiro 2 bytes 2 O comprimento normalmente não representa uma preocupação prática, pois dificilmente se trabalha com nomes de identificadores muito longos.
char Caractere 1 byte float double Numero de Ponto Flutuante (precisão simples) Numero de Ponto Flutuante (precisão dupla) 4 bytes 8 bytes Os qualificadores podem ser utilizados para a ampliação de alguns dos tipos de dados básicos. A tabela a seguir ilustra a utilização de qualificadores com o tipo int. short long signed unsigned (int) 2.2.4. Constantes As constantes podem ser inteiras, de ponto flutuante, caractere, ou strings (cadeias de caracteres). a) Constantes Inteiras Exemplos: 0 1 347 32766 9997-25 (o caractere - é um operador mudando o sinal da constante) 0900 (constante inválida, pois o primeiro dígito deve ser diferente de 0) Constantes unsigned e long (int): Exemplos: 5000u 123579870l 124569989ul (Unsigned) (Long) (Unsigned Long) Os tipos das constantes são caracterizados pelos sufixos adicionados aos números: u ou U(unsigned), l ou L(long) e ul ou UL (unsigned long). b) Constantes de Ponto Flutuante Uma constante de ponto flutuante é um numero na base 10 que contém um ponto decimal ou um expoente (ou ambos).
Exemplos: Constantes válidas: 0. 1. 0.2 500. 0.00629 12.57 2E-6 0.052e-4.123314e-24 Constantes inválidas (caractere incorreto sublinhado): 1 3,000.0 2E+20.5 40E 20 5 Codificações possíveis para 3 10 : 300000. 3e5 3e+5 3E5 3.0e+5.3e6 300e3 Faixa de variação (aproximada) para valores dos tipos float (precisão simples) e double (precisão dupla): Precisão simples: 38 3,4 10 a 38 3,4 10 0,0 38 3,4 10 a 3,4 10 38 Precisão dupla: 308 1,7 10 a 308 1,7 10 0,0 308 1,7 10 a 1,7 10 308 c) Constantes Caracteres São formadas por caracteres do conjunto de caracteres do computador, delimitados por apóstrofos (aspas simples: '). Exemplos: 'A', 'X', 'a', '3', '$', ' ',... Os valores das constantes caracteres correspondem aos valores dos códigos ASCII correspondentes aos caracteres. A tabela a seguir apresenta os valores de algumas constantes caracteres Valores de algumas constantes caracteres: Constante Valor (código ASCII)
'A' 65 'B' 66 'C' 67 'a' 97 'z' 122 '$' 36 '&' 38 Seqüências de Escape : normalmente comparecem em constantes strings, como será visto mais adiante. Caractere Seqüência de escape Campainha \a Tabulação Horizontal \t Tabulação Vertical \v Nova Linha \n Carriage Return \r Aspas (") \" Apostrofo(') \' Interrogação (?) \? \ \\ Nulo \0 Observações: cada seqüência de escape, como o '\n' por exemplo,é considerado como um caractere na Linguagem C. A seqüência '\0', caractere nulo, corresponde ao caractere que é inserido no final de cada string (cadeia de caracteres), como será visto mais adiante. d) Constantes Strings Uma constante string é uma cadeia de caracteres delimitada por aspas ("..."). Exemplos: "Verde" "Guaratinguetá"
"Linha1 \n Linha2 \n Linha3" A constante string no comando printf a seguir faz uso de seqüências de escape para que aspas (") possam ser incluídas na constante: Printf("\t Pressione a tecla \"Return\" para continuar\n"); O compilador da Linguagem C acrescenta um caractere nulo ('\0') ao final de toda constante string. A constante string "A" consiste, de fato, de 2 caracteres, a saber: ' A ','\0', ou seja, consiste do caractere 'A' seguido de um caractere nulo ('\0'). Deve-se estar atento para não confundir os diferentes tipos de elementos providos pela linguagem C. Estude as diferenças entre os exemplos de elementos apresentados na tabela a seguir. Exemplo 'A' "A" A Significado Constante caractere Constante string Identificador 3 Constante numérica (inteira) '3' Constante caractere 2.2.5. Declarações de variáveis Declarações de variáveis são efetuadas de acordo com a forma geral a seguir: <tipo> <lista de variáveis>; onde: <tipo> corresponde ao tipo do valor que pode ser armazenado nas variáveis que estão sendo declaradas. Qualificadores podem ser utilizados. <lista de variáveis> é uma lista contendo uma ou mais variáveis, separadas por vírgulas. O ponto-e-vírgula no final separa esta declaração da próxima instrução do programa. Exemplos 3 : /* Declarações de Variáveis: tipos básicos */ 3 No ambiente Dev-C++ os tipos aparecem em negrito no código de um programa.
int a,b,c; /*Tipo básico inteiro */ float raiz1, raiz2; /*real de precisão simples */ char flag,texto[80]; /* texto vetor: vetor com 80 elementos tipo caractere */ /* Declarações de Variáveis: qualificadores */ short int a,b,c ; long int r,s,t; int p,q; Ou, de forma mais simples: short a,b,c; long r,s,t; int p,q; /* Declarações de Variáveis: tipos, qualificadores */ int a1, b1; unsigned xa, yb; double r1, r2; /* ou long float 4 r1,r2; */ Valores iniciais podem ser atribuídos às variáveis nas mesmas instruções em que são declaradas. Estes valores podem ser alterados durante a execução do programa em que as variáveis são declaradas. /* declarações de variáveis: valores iniciais */ int d=20; char asterisco = '*'; float result = 0.0; double precis = 0.21246e-6; 2.2.6. Constantes Simbólicas Uma constante simbólica é um nome dado a uma seqüência de caracteres, podendo ser utilizado no código do programa em que foi definida para designar aquela seqüência. Constantes simbólicas podem ser empregadas para representar constantes numéricas, caracteres ou constantes do tipo string. Na fase de compilação, cada ocorrência de uma constante simbólica é substituída pela seqüência de caracteres utilizada na sua definição. A definição de uma constante simbólica normalmente ocorre no inicio do programa, tendo a forma geral: onde: #define <nome_constante> <texto> 4 Não permitido no Dev-C++.
<nome_constante> identificador para a constante, é normalmente escrito em letras maiúsculas. <texto> seqüência de caracteres de definição da constante. Exemplos: // Definiçãqo de Constantes #define TAXA 0.15 #define PI 3.141593 #define VERDADE 1 #define FALSO 0 #define AMIGO "Professor" Observações: (i) Considere o trecho de programa a seguir: #define PI 3.141593 float raio, area;... // emprego de constante simbólica area = PI * raio * raio;... Após a compilação, a instrução referente ao cálculo da área se torna: area = 3.141593 * raio * raio; Observe-se que a substituição é literal, ou seja, se no trecho de programa acima a constante fosse definida como segue: #define PI 3.141593; Após a compilação, a instrução referente ao cálculo da área se torna: area = 3.141593; * raio * raio; (ii) A substituição do texto não ocorre se a constante comparece em uma cadeia de caracteres ( string ). (iii) A definição de uma constante simbólica é uma característica incluída no préprecessador C, que é o programa responsável pelo primeiro passo na tradução de um programa C. 2.2.7. Operadores e Expressões a) Introdução a Expressões
Exemplos: Expressões Simples : a+b x = y c=a+x x >= b x == y ++i (atribuição) (teste de igualdade) (incremento) b) Expressões Aritméticas b.1) Operadores aritméticos São os seguinte: +, -, *, /, %. As seguintes observações se aplicam a estes operadores: (i) Operador %: Retorna o resto da divisão inteira. (ii) Exponenciação em C: Efetuada com a utilização da função pow, como será descrito mais adiante neste capítulo. (iii) a/b, com a e b inteiros: Divisão inteira (quociente truncado). (iv) a % b: Os operandos a e b devem ser inteiros, com b 0. (v) A+B, A-B, A*B, A/B: Os operandos A e B podem ser dos tipos inteiro (int), ponto flutuante (float; double) ou caractere (char). int a=10, b=3; Expressão: Resultado da avaliação: a+b 13 a-b 7 a*b 30 a/b 3 a%b 1 char c1,c2; c1 = 'A' /* ASCII 65 */ c2 = 'a'; /* ASCII 97 */ /* cte '2' -> ASCII 50 */
Expressão: Resultado da avaliação: c1 + c2 162 c1 + c2 + 2 164 c1 + c2 + '2' 212 No caso do operador %, quando um dos operandos for negativo, o resultado da operação será o resto da divisão com sinal do primeiro operando. int a=11, b=-3; Expressão: Resultado da avaliação: Verificação: a / b -3 a % b a 2 a b * b a % b 3 3 2 9 11 int a=-11, b=3; Expressão: Resultado da avaliação: Verificação: a / b -3 a % b a -2 a b * b a % b 3 3 2 9 11 b.2) Conversão de tipo na Avaliação Em geral o resultado final será expresso com a maior precisão possível, conforme o tipo de dado dos operandos envolvidos na operação. Declarações: Expressão: Tipo do valor resultante: float a; double b; a + b double.
Declarações: Expressão: Tipo do valor resultante: float a; char b; int c; a + b a + c float Para a conversão do resultado de uma expressão para um tipo de dados desejado pode ser utilizado um construtor de de cast, cuja forma geral é a seguinte: (<tipo_de_dado>) <expressão> onde <tipo_de_dado> designa o tipo de dado para o qual o resultado da <expressão> deverá ser convertido. Exemplos: Declarações: Expressão: Observação: int i = 8; Operação inválida, pois os dois float f = 9.7; (i + f) % 4; operandos deveriam ser do tipo int, o que não ocorre neste caso: i f % 4 float ((int)(i + f)) % 4 ((int) f) % 3 Operação válida, pois, neste caso os dois operandos são do tipo int: int i f ) % 4 int Operação válida: int f % 3 Observe-se que neste caso o valor de f será truncado (antes do cálculo do resto da divisão). b.3) Precedência de Operadores Para o caso dos operadores aritméticos, a precedência é definida como mostrado na tabela a seguir:
Ordem de precedência Operadores (i) * / % (ii) + - Dentro de um mesmo grupo de precedência, a associatividade é da esquerda para direita. Por exemplo, no caso de uma multiplicação seguida de uma divisão, a multiplicação é efetuada primeiro. Exemplos: Ordem de avaliação de algumas expressões: Expressão aritmética (C) Ordem de avaliação Expressão equivalente a * b / c a b/c * d a * b / c R1 R2 a b / c * d R1 R2 R3 ab c b a d c Considere a seguinte expressão aritmética: w = 2 * ((i % 5) * (4 + (j 3)/(k + 2))) Uma solução equivalente e em princípio melhor, em termos de legibilidade, é dada por: u = i % 5; v = 4 + (j 3)/(k + 2); w = 2 * (u * v); b.4) Operadores Unários Estudaremos nesta seção os seguintes operadores unários: Operador Significado - Menos unário ++ Operador de incremento -- Operador de decremento Sizeof Retorna o tamanho de seu operando, em bytes (tipo) Construtor de cast (conversão de tipo)
Exemplos e detalhamento destes operadores são apresentados a seguir, com exceção do construtor de cast, já apresentado na seção (b.2). Observe-se que a associatividade dos operadores unários é da direita para a esquerda. b.4.1) Menos unário Exemplos: -727 -(x + y) -5e-32 -a b.4.2) Operadores de incremento e decremento Suponha que i seja uma variável inteira. A tabela a seguir apresenta o significado das operações de incremento (++) e decremento (--) aplicadas à variável i. Expressão Equivalente a: ++i i i + 1 --i i i - 1 Os operadores de incremento e decremento podem anteceder ou seguir um identificador de variável, com significados distintos, como esclarece a tabela a seguir. Expressão ++i i++ Observações O valor corrente de i é incrementado e o novo valor é utilizado no contexto em que a expressão comparece. O valor corrente de i é utilizado no contexto em que a expressão aparece, após o que o valor de i será incrementado. Exemplos: Considere os trechos de programas a seguir, em que comparecem operações de incremento e decremento. Os comentários ao lado das instruções mostram os valores atribuídos às variáveis após a execução das respectivas instruções. int i = 10, j, k; j = ++i; /* i = 11; j = 11 */ k = --i; /* i = 10; k = 10 */ int i = 10, j, k; j = i++; /* j = 10; i = 11 */ k = i--; /* k = 11; i = 10 */ b.4.2) Operador sizeof
O programa a seguir apresenta o tamanho requerido em bytes para armazenar valores de cada um dos tipos de dados básicos da Linguagem C, no ambiente do Dev-C++. // Operador sizeof: memória requerida // para dados dos tipos básicos // Programador: Sena Ano: 2010 #include <stdio.h> int main(void) { /* Teste do operador sizeof */ int i; float x; double y; char c; printf ("\n\n\tint: \t%d\n",sizeof i); printf ("\tfloat: \t%d\n", sizeof x); printf ("\tdouble:\t%d\n", sizeof y); printf ("\tchar: \t%d\n\n", sizeof c); system("pause"); } Tela de execução: O programa a seguir corresponde a uma variação do programa anterior, utilizando o construtor de cast: // Operador sizeof: memória requerida para dados // dos tipos básicos: uso de construtor de cast // Programador: Sena Ano: 2010 #include <stdio.h> int main(void) { /* Teste do operador sizeof */ printf ("\n\n\tint: \t%d\n",sizeof (int)); printf ("\tfloat: \t%d\n", sizeof (float)); printf ("\tdouble:\t%d\n", sizeof (double)); printf ("\tchar: \t%d\n\n", sizeof (char)); system("pause"); }
c) Operadores Relacionais e Lógicos c.1) Operadores Relacionais: < <= > >= Operadores de Igualdade: == (igual a)!= (diferente: não igual a ) Uma expressão construída utilizando os operadores relacionais, e que também pode incluir os operadores lógicos (estudados a seguir) é uma expressão lógica. Uma expressão lógica é avaliada como verdadeiro (representado pelo valor inteiro 1) ou falso (representado pelo valor inteiro 0). int i=1, j=2, k=3; float f = 5.5; char c = 'w'; /* ASCII 119 */ Expressão: Resultado da avaliação: i < j 1 (j+k) > (i+j) 1 j!= 2 0 i == 1 1 (i+f) <= 5 0 c == 119 1 c!= 'q' 1 c <= 5*(i+f) 0 Note-se que o resultado da avaliação pode, por exemplo, ser armazenado numa variável inteira, como mostra o exemplo a seguir: // Operadores relacionais // Programador: Sena Ano: 2010 #include <stdio.h> int main(void) { /* Declaração de variáveis */ int i = 1; float f = 5.5; char c = 'w'; /* ASCII 119 */
} int r; /* resultado avaliação */ /* av. expressao relacional */ r = c <= 5*(i+f); /* saida e pausa */ printf ("\nresultado de c <= 5*(i+f) = %2d\n",r); system("pause"); Tela de execução: c.2) Operadores ( ou conectores ) Lógicos Operador && Significado e ( and : conjunção lógica) ou ( or : disjunção lógica)! não ( not : negação lógica) Os operandos das expressões construídas com estes operadores devem ser expressões lógicas. A avaliação das expressões envolvendo os operadores lógicos é efetuada em conformidade com a tabela de verdade: nesta são apresentados os resultados da avaliação das expressões em função dos valores dos operandos lógicos envolvidos, como mostrado a seguir. Tabela de verdade Operandos a e b: expressões lógicas a b a && b a b!a!b 1 1 1 1 0 0 1 0 0 1 0 1 0 1 0 1 1 0 0 0 0 0 1 1 int i = 7; float f = 5.7; char c = 'w'; /* ASCII 119 */
Expressão: Resultado da avaliação: (i >= 5) && (c == 'w') 1 (c!= 'r') && (c == 119) 1 (f > 11) (c < 'a') 0 (f <= 11) (i > 100) 1 Observação: (f <= 11) (i++ > 100) 1 i = 7 (f<=11) (++i > 100) 1 i = 7 (f<=11) && (++i == 8) 1 i = 8 (f<=11) && (i++ == 8) 0 i = 8 f > 5 1!(f > 5) 0!(i > (f + 1)) 0 A tabela a seguir mostra como os operadores estudados até este ponto são manipulados na Linguagem C, em termos de precedência e associatividade. Operador(es) Precedência Associatividade - ++ --! sizeof (tipo) ( 1 ) D E * / % ( 2 ) E D + - ( 3 ) E D < <= > >= ( 4 ) E D ==!= ( 5 ) E D && ( 6 ) E D ( 7 ) E D Tendo em conta a precedência de operadores em C, muitas vezes parênteses podem ser excluídos, sem que isto comprometa o resultado da avaliação, como mostra o exemplo a seguir: (c!= 'p') ((i + f) <= 10) c!= 'p' i + f <= 10 Não obstante, recomenda-se o emprego de parênteses mesmo que não sejam necessários, sempre que o seu uso puder contribuir para a clareza da codificação.
Ainda com relação à avaliação de expressões numéricas, em geral, na Linguagem C, as operações envolvendo operadores aritméticos são avaliadas inicialmente, sendo seguidas pelas operações envolvendo os operadores relacionais e, por último, são avaliadas as operações envolvendo os operadores lógicos. 2.2.8. Operadores de Atribuição a) Atribuições Simples O operador de atribuição é o = (não confundir com ==, operador de igualdade). Forma geral de uma atribuição: <identificador> = <expressão> Exemplos: Abaixo são apresentados alguns exemplos de instruções de atribuição. a = 3 eps = 0.001 x = z area = base * altura Quando os operandos são de tipos diferentes em uma expressão de atribuição, o valor da expressão à direita é convertido para o tipo do identificador à esquerda do operador de atribuição. A tabela a seguir ilustra duas situações, apresentando, em cada uma delas, os tipos da expressão (e) e da variável (v) e a conversão efetuada pelo processador da linguagem. v e; e float v int v e; e double v float O valor de e é truncado. O valor de e é arredondado. Exemplos: int i, j = 5; /* declaração de variáveis */ Instrução de atribuição: Valor atribuído: i = j; /* ( i = 5 ) */ i = j / 2; /* ( i = 2 ) */ i = 2 * j / 2; /* ( i = 5 ) */
i = 2 * (j / 2); /* ( i = 4 ) */ i = 'x'; /* ( i = 120 ) */ i = '0'; /* ( i = 48 ) */ i = ('x' '0') / 3; /* ( i = 24 ) */ i = ('y' '0') / 3; /* ( i = 24 ) */ b) Atribuições Múltiplas Forma geral: id1 id 2 expressão onde id i designa o i-ésimo identificador. Note-se que no caso de atribuições múltiplas, a associatividade feita da direita para a esquerda: id id expressão id id expressão 1 2 1 2 Exemplos: int i, j; /* declaração de variáveis */ Instrução de atribuição: Valores atribuídos: i = j = 5; /* j = 5; i = 5 */ i = j = 5.9; /* j = 5; I = 5 */ c) Operadores: +=, -+, *=, /=, %= Apresenta-se, a seguir, a sintaxe e a semântica dos operadores += e -+. Na descrição a seguir, id designa um identificador e expr, uma expressão. id += expr id = id + expr id *= expr id = id * expr Exemplos: /* declaração de variáveis */ int i = 5, j = 7; float f = 5.5, g = -3.25; Instrução de atribuição: Valor atribuído:
i += 5 ; /* ( i = 10 ) */ f -= g ; /* ( f = 8.75 ) */ j *= ( i 3 ); /* ( j = 14 ) */ f /= 3; /* ( f = 1.833333 ) */ i %= (j 2 ); /* ( i = 0 ) */ Com relação à precedência dos operadores de atribuição, inclui-se a linha mostrada abaixo na tabela de precedências apresentada anteriormente: Operador(es) Precedência Associatividade = += -= *= /+ %= ( 9 ) D E 2.2.9. Operador Condicional (? :) Este operador é utilizado na construção de uma expressão condicional, cuja forma geral é a seguinte: expressão 1? expressão 2 : exp ressão 3 A semântica de uma expressão condicional é a seguinte: se a expressão 1 for avaliada como verdadeira, então execute a expressão 2, caso contrário, execute a expressão 3. flag = (i < 0)? 0 : 100; /* se i < 0 então flog = 0 senão flog = 100 */ min = (f < g) f : g; /* atribui a min o menor valor entre f e g */ int a = 1, b = 2, c = 3... c += (a > 0 && a <= 10)? ++a : a / b; Apresenta-se, a seguir, a avaliação da expressão condicional, evidenciando o valor que será atribuído à variável c.
c a 0 && a 10? a : 1 1 a 2 1 c 5 a / b Com relação à precedência do operador condicional, inclui-se a linha mostrada abaixo na tabela de precedências apresentada anteriormente: Operador(es) Precedência Associatividade? : ( 8 ) D E 2.2.10. Funções de Biblioteca Características gerais: Não fazem parte da linguagem, apesar de todas as implantações as incluírem. Funções de biblioteca similares normalmente são agrupadas como programasobjeto em bibliotecas separadas. A tabela a seguir apresenta alguns exemplos de funções de biblioteca da Linguagem C. Na tabela a seguir, a coluna Tipo se refere ao tipo do valor retornado. Com relação aos argumentos a serem especificados na chamada destas funções, observar a legenda apresentada a seguir: c: argumento do tipo char. i: argumento do tipo int. d: argunto do tipo double. u: argumento do tipo unsigned. Exemplos de Funções de Biblioteca Função Tipo Descrição abs(i) int i cos(d) cosh(d) double double exp(d) double d e fabs(d) double d fmod(d1,d2) double Retorna a parte não inteira do quociente de d1/d2,com sinal de d1
log(d) double ln(d ) pow(d1,d2) double d2 d printf( ) int Impressão rand() int Retorna aleatoriamente, um inteiro positivo sin(d) double sqrt(d) double d srand(u) void 5 Inicializa o gerador de números aleatórios scanf (...) int Entrada de dados tan(d) double tg (d) toascii(c) int Converte o valor do argumento para ASCII tolower(c) int Converte o caractere armazenado em c, se uma letra maiúscula, para uma letra minúscula. Nenhuma conversão é efetuada para os demais caracteres. toupper(c) int Como no caso da função anterior, mas convertendo a letra para uma letra maiúscula. 1 Exercícios [2]: 1) Apresentar a ordem de execução e o resultado da avaliação de: int i=1, j=2; int x, y, a, b; a) y = (2*j+1+i)/++i*j++; b) i = j = (++i + ++j) / j++; c) a = ++j + --j * (b = 7/2); 2) Como será avaliada a expressão x +++y: a) x++ + y b) x + ++y 3) Apresentar os valores que serão atribuídos a cada uma das variáveis, após a avaliação das expressões a seguir: int a=1, b=2, c=3, d=4; 5 void: a função não retorna nenhum valor.
a) a += b + c; b) b *= c = d + 2; c) d %= a + a + a; d) d -= c-= b -=a; e) a += b += c += 7; 4) Apresentar o valor que será atribuído a k após a avaliação da expressão a seguir: int k, j = 3; k= j==3; 5) Indicar a ordem de avaliação e apresentar o resultado da avaliação das expressões a seguir: int i=1, j=2, k=3, n=2; float x = 3.3, y = 4.4; a) i < j+3 b) 2 * i 7 <= j 8 c) x == y d)!(n - j) e)!n j f)!x *!x g) i && j && k h) i j-3 && 0 i) i == 2 j==4 k==5 j) i=2 j==4 k == 5 k) x < 5.0 && x!= 1.0 i > j 6) Reescrever, sem usar o operador de negação (!) a)!(i==j) b)!(i+1 < j-2) c)!(i<j && n < m) d)!(i<j j<2 && n<3) Referências Bibliográficas 1. Ascencio, A. F. G.; Campos, E. A. V. Fundamentos da programação de computadores. São Paulo: Prentice Hall, 2002. 2. Gottfried, B. S. Programming with C. McGraw-Hill, 1991. 3. Mizrahi, V.V. Treinamento em Linguagem C. São Paulo: Pearson Prentice Hall, 2008. 4. Sene, E.L.F. Primeiro Curso de Programação em C. Florianópolis: Visual Books, 2009.