Programar em C
185 pág.

Programar em C


DisciplinaLinguagem de Programação Estruturada128 materiais1.053 seguidores
Pré-visualização40 páginas
float f = 3.0;
 f = f + j / i;
 printf("O valor de f é %f", f);
 return 0;
}
Operações matemáticas (Básico) 30
Mas, segundo a precedência dos operadores, j / i deveria ser calculado primeiro, e como ambos os valores são
do tipo inteiro, o valor dessa expressão é zero.
É importante que você grave um arquivo .c com o código acima e execute usando o compilador para ver o
funcionamento com os próprios olhos.
Abreviações
Alguns tipos de atribuições são bastante comuns, e por isso foram criadas abreviações. Por exemplo, é muito comum
incrementar em uma unidade o valor de uma variável (em loops, por exemplo). Em vez de escrever var = var +
1, podemos escrever simplesmente var++. Da mesma maneira, existe o operador de decremento, que decrementa
em uma unidade o valor da variável: var-- (equivalente a var = var - 1).
Os operadores de decremento e incremento também podem ser utilizados antes do nome da variável. Isso significa
que estas duas instruções são equivalentes:
var++;
++var;
Agora vamos supor que você use em seu programa uma variável que aumenta de 10 em 10 unidades. É claro que
usar var++ dez vezes não abreviaria nada. Em vez disso, existe a abreviação var += 10.
Genericamente, para qualquer dos cinco operadores aritméticos op, vale a abreviação:
var = var op num;
var op= num;
Ou seja, os seguintes pares são equivalentes:
x *= 12; x = x * 12;
x /= 10; x = x / 10;
x -= 2; x = x - 2;
x %= 11; x = x % 11;
Este exemplo clarifica o uso dos operadores de incremento:
#include <stdio.h>
int main()
{
 int a, b;
 a = b = 5;
 printf(&quot;%d\n&quot;, ++a + 5);
 printf(&quot;%d\n&quot;, a);
 printf(&quot;%d\n&quot;, b++ + 5);
 printf(&quot;%d\n&quot;, b);
 return 0;
}
O resultado que você deve obter ao executar o exemplo é:
11
6
10
6
Operações matemáticas (Básico) 31
Esse resultado mostra que ++var e var++ não são a mesma coisa se usados como uma expressão. Quando
usamos os operadores na forma prefixal (antes do nome da variável), o valor é retornado depois de ser incrementado;
na forma sufixal, o valor é retornado e depois incrementado. O mesmo vale para o operador de decremento.
E o que aconteceria se você escrevesse algo como o seguinte?
printf(&quot;%d\n&quot;, a / ++a);
A resposta é: não sabemos. Segundo o padrão C, o resultado disso é indefinido (o que significa que pode variar de
um compilador para outro). Não existe uma regra sobre avaliar primeiro o numerador ou o denominador de uma
fração. Ou seja, não use uma variável mais de uma vez numa expressão se usar operadores que a modificam.
Talvez você tenha achado estranha a linha:
a = b = 5;
Isso é possível porque atribuições são feitas da direita para a esquerda e uma instrução de atribuição é também uma
expressão que retorna o valor atribuído. Ou seja, a expressão b = 5 retornou o valor 5, que foi usado pela
atribuição a = (b = 5), equivalente a a = 5.
Operações matemáticas (Avançado)
O cabeçalho <math.h> contém protótipos de algumas funções na área de matemática. Na versão de 1990 do
padrão ISO, somente a versão double das funções foram específicadas; na versão de 1999 foram adicionadas as
versões float e long double.
As funções podem ser agrupadas nas seguintes categorias:
1.1. Funções Trigonométricas
2.2. Funções Hiperbólicas
3.3. Funções Exponencial e Logaritmo
4.4. Funções pow e sqrt
5.5. Funções de Arredondamento para Números Inteiros, Valores Absolutos e Resto da Divisão
Funções Trigonométricas
As funções acos e asin
A função acos retorna o arco-cosseno dos seus argumentos em radianos, e a função asin retorna o arco-seno dos
seus argumentos em radianos. Todas as funções esperam por argumentos que estejam no intervalo [-1,+1]. O
arco-cosseno retorna valores no intervalo [0,\u3c0]; o arco-seno retorna valores no intervalo [-\u3c0/2,+\u3c0/2].
#include <math.h>
float asinf(float x); /* C99 */
float acosf(float x); /* C99 */
double asin(double x);
double acos(double x);
long double asinl(long double x); /* C99 */
long double acosl(long double x); /* C99 */
Operações matemáticas (Avançado) 32
As funções atan e atan2
As funções atan retornam o arco-tangente dos arguments em radianos, e a função atan2 retorna o arco-tangente
de y/x em radianos. As funções atan retornam o valor no intervalo [-\u3c0/2,+\u3c0/2] (a razão pelo que ±\u3c0/2 está
incluido no intervalo é porque os valores decimais pode representar o infinito, e atan(±\u221e) = ±\u3c0/2); as funções
atan2 retornam o valor no intervalo [-\u3c0,+\u3c0]. Para a função atan2, um &quot;domain error&quot; pode ocorrer se os dois
argumentos forem zero.
#include <math.h>
float atanf(float x); /* C99 */
float atan2f(float y, float x); /* C99 */
double atan(double x);
double atan2(double y, double x);
long double atanl(long double x); /* C99 */
long double atan2l(long double y, long double x); /* C99 */
As funções cos, sin e tan
As funções cos, sin, e tan retornam o coseno, seno, e tangente do argumento, expresso em radianos.
#include <math.h>
float cosf(float x); /* C99 */
float sinf(float x); /* C99 */
float tanf(float x); /* C99 */
double cos(double x);
double sin(double x);
double tan(double x);
long double cosl(long double x); /* C99 */
long double sinl(long double x); /* C99 */
long double tanl(long double x); /* C99 */
Funções Hiperbólicas
As funções cosh, sinh and tanh computam o coseno hiperbólico, o seno hiperbólico e a tangente hiperbólica
respectivamente. Para as funções de seno e coseno hiperbólico, um erro de ...
#include <math.h>
float coshf(float x); /* C99 */
float sinhf(float x); /* C99 */
float tanhf(float x); /* C99 */
double cosh(double x); 
double sinh(double x);
double tanh(double x);
long double coshl(long double x); /* C99 */
long double sinhl(long double x); /* C99 */
long double tanhl(long double x); /* C99 */
Operações matemáticas (Avançado) 33
Funções Exponencial e Logaritmo
A função exp
As funções exp computam a função exponencial de x (ex). Um &quot;range error&quot; ocorre se o valor de x é muito
grande.
#include <math.h>
float expf(float x); /* C99 */
double exp(double x);
long double expl(long double x); /* C99 */
As funções frexp, ldexp e modf
As funções frexp dividem um número real numa fração normalizada e um número inteiro múltiplo de 2. As
funções guardam o número inteiro no objeto apontado por ex.
As funções frexp retornam o valor x de forma que x tem o valor [1/2, 1) ou zero, e value é igual a x vezes 2
elevado a *ex. Se value for zero, as duas partes do resultado seram zero.
As funções ldexp multiplicam um número real por um número inteiro múltiplo de 2 e retornam o resultado. Um
&quot;range error&quot; pode ocorrer.
As funções modf divide o argumento value entre um parte inteira e uma fração, cada uma tem o mesmo sinal do
argumento. As funções guardam o parte inteira no objeto apontado por *iptr e retornam o fração.
#include <math.h>
float frexpf(float value, int *ex); /* C99 */
double frexp(double value, int *ex);
long double frexpl(long double value, int *ex); /* C99 */
float ldexpf(float x, int ex); /* C99 */
double ldexp(double x, int ex);
long double ldexpl(long double x, int ex); /* C99 */
float modff(float value, float *iptr); /* C99 */
double modf(double value, double *iptr); 
long double modfl(long double value, long double *iptr); /* C99 */
As funções log e log10
As funções log computam o logaritmo natural do argumento e retornam o resultado. Um &quot;domain error&quot; ocorre se
o argumento for negativo. Um &quot;range error&quot; pode ocorrer se o argumento for zero.
As funçõs log10 computam o logaritmo comum (base-10) do argumento e retornam o resultado. Um &quot;domain
error&quot; ocorre se o argumento for negativo. Um &quot;range error&quot; ocorre se o argumento for zero.
#include <math.h>
float logf(float x); /* C99 */
double log(double x);
long double logl(long double x);