De Objective Caml para C e C++
57 pág.

De Objective Caml para C e C++


DisciplinaEstrutura de Dados I8.855 materiais180.927 seguidores
Pré-visualização14 páginas
raiz quadrada. double sqrt(double
x);
float sqrtf(float x); long double sqrtl(long
double x);
raiz cúbica: double cbrt(double
x);
float cbrtf(float x); long double cbrtl(long
double x);
valor absoluto: double fabs(double
x);
float fabsf(float x); long double fabsl(long
double x);
potência: double pow(double x,
double y);
float powf(float x,
float y);
long double powl(long double
x, long double y);
arredondamento para cima: double ceil(double
x);
float ceilf(float x); long double ceill(long
double x);
arredondamento para baixo: double floor(double
x);
float floorf(float
x);
long double floorl(long
double x);
arredondamento para o inteiro mais
próximo:
double round(double
x);
float roundf(float
x);
long double roundl(long
double x);
arredondamento para o mais
próximo int:
int rint(double x); int rintf(float x); int rintl(long double x);
arredondamento para o mais
próximo long int:
long int lrint(double
x);
long int lrintf(float
x);
long int lrintl(long double
x);
arredondamento para o mais
próximo long long int:
long long int
llrint(double x);
long long int
llrintf(float x);
long long int llrintl(long
double x);
truncamento: double trunc(double
x);
float truncf(float
x);
long double truncl(long
double x);
Os tipos básicos 14
Apresentamos de forma muito superficial os tipos flutuantes. A biblioteca padrão oferece outras funcionalidades, em
particular permite um controle muito afinado de problemas de precisão e de estouro. As funções apresentadas devem
porém devem satisfazer 99,9% das necessidades de programação.
Variáveis e funções
Variáveis
A definição de uma variável faz-se com a seguinte sintaxe:
tipo nome = valor;
onde tipo é uma expressão que define o tipo da variável, nome é o nome da variável, e valor é uma expressão
que define o valor inicial da variável. Diferente de Objective Caml, não é obrigatório associar um valor inicial a uma
variável e a seguinte sintaxe também é legal:
tipo nome;
Seguem então alguns exemplos:
char c = 'a';
int i = 0;
long long num;
Na primeira linha, é definida uma variável, cujo nome é c, o tipo é char e que tem como valor inicial 'a'. Na
segunda linha, é definida uma variável nomeada i, de tipo inteiro, cujo valor inicial é 0. Enfim, na terceira linha, é
definida uma variável de nome num, de tipo long long, e cujo valor é qualquer.
Pode se definir múltiplas variáveis do mesmo tipo, separando seus nomes por vírgulas. Assim, na linha seguinte, são
definidas três variáveis inteiras, chamadas respectivamente i, j, e k, onde apenas j possui um valor inicial, que é
2.
int i, j = 2, k;
Funções
A definição de uma função faz-se com a seguinte sintaxe:
tipo nome (parametros)
corpo
onde tipo é o tipo de retorno da função, nome é o nome da função, parametros é a lista de parâmetros da
função e corpo é um bloco de instruções.
argumentos é uma lista de declarações de parâmetros separadas por vírgulas. Essa lista pode ser vazia, quando a
função não possui nenhum parâmetro. Cada parâmetro é declarado com seu tipo e o seu nome.
corpo é um bloco, entre símbolos de chaves de instruções C/C++. Veremos mais adiante quais construções
podemos utilizar, por enquanto basta saber que um bloco pode conter declarações de variáveis e instruções
algorítmicas similares aquelas da linguagem Objective Caml (atribuição de variável, chamada de função, construções
condicionais e repetitivas). Uma diferença significativa é que um bloco C ou C++ não pode conter a definição de
uma função, portanto não existe o conceito de uma função local a outra função.
Segue agora um exemplo completo de uma função:
Variáveis e funções 15
int square (int n)
{
 return n * n;
}
Parâmetros opcionais
A linguagem C++ oferece algumas facilidades relacionadas aos parâmetros que não existem na linguagem C. Assim,
é possível dar um valor defaut a alguns parâmetros de uma função. Vejamos isso com base um exemplo:
int f (int a, int b = 0)
{
 return a + b;
}
int g (int k)
{
 return f (k);
}
A função f possui dois parâmetros, porém o segundo (nomeado b) é opcional. Quando a função f é chamada
dentro da função g, o parâmetro opcional recebe o valor defaut especificado na definição da função, no caso desse
exemplo. O mecanismo de associação entre parâmetros efetivos e parâmetros formais é realizado da esquerda para a
direita. Quando o número de parâmetros efetivos é menor que o número de parâmetros formais, esses últimos
recebem o valor defaut especificado na definição da função. Se não houver valor defaut especificado, então ocorrerá
um erro na compilação.
Considere agora o seguinte programa:
#include <iostream>
using namespace std;
int f2 (int a = 1, int b = 2, int c = 3)
{
 return a * b * c;
}
int main g()
{
 cout << f2() << endl;
 cout << f2(5) << endl;
 cout << f2(5, 10) << endl;
 cout << f2(5, 10, 15) << endl;
 return 0;
}
A saída será:
6
30
150
750
Variáveis e funções 16
Na primeira chamada, não há parâmetros efetivos, logo os parâmetros formais receberão seu valor defaut e o
resultado é . Na segunda chamada, há um parâmetro efetivo, que será associado ao primeiro
parâmetro formal, e o resultado é . Na terceira chamada, há dois parâmetros efetivos, que serão
associados aos dois primeiros parâmetros formais, e o resultado é . Na quarta e última
chamada, há tr\u2c6´s parâmetros efetivos, que são associados aos parâmetros formais, e o resultado é
.
Vale salientar que uma função pode ter um número qualquer de parâmetros opcionais, mas eles devem aparecer nas
últimas posições da lista de parâmetros. Assim a seguinte definição de função é ilegal:
int uma_funcao_mal_definida (int a = 0, int b)
{
 return a + b;
}
Sobrecarga
Em c++ é possivel fazer com que duas ou mais funções diferentes tenham o mesmo nome desde que tenham
parâmetros diferentes e isso é chamado de sobrecarga de função por exemplo:
# include <iostream>
# include <string>
using namespace std;
int soma (int a,int b)
 {
 return a + b;
 }
float soma (float a,float b)
 {
 return a + b;
 }
string soma (char a,char b)
{
 return a + b;
} 
Nenhuma dessas três funções soma seria sobreescrevida ou ocorreria um erro pois todas possuem paramentros
diferentes e para chama-las é necessário apenas colocar os parâmetros correspondentes por exemplo:
soma (a,b);
Isso chamaria a terceira função de soma que tem como parâmetros dois caracteres.
Instruções 17
Instruções
Instruções de expressão
As instruções de expressão compõem a forma mais simples de construir uma instrução, pois permite instruir o
compilador que uma dada expressão deve ser avaliada nesse ponto. A sintaxe da instrução de expressão é:
expressao;
Ou seja, é apenas uma expressão seguida de um ponto e vírgula. A seguir vamos então ver quais são as expressões
que são mais frequentemente encontradas em instrução expressão.
Além das expressões sobre os tipos básicos já apresentadas, existem uma série de expressões diferentes providas que
permitem compor os blocos básicos de algoritmos seqüênciais. São elas:
\u2022\u2022 Atribuição;
\u2022\u2022 Chamada de função;
\u2022\u2022 Pós-incremento;
\u2022\u2022 Pré-incremento;
\u2022\u2022 Atribuição composta;
\u2022\u2022 Composição sequencial.
Atribuição
A sintaxe da atribuição em C e C++ é a seguinte:
alvo = expressao
A semântica dessa construção é a seguinte: a expressão fonte expressao é avaliada, e o valor resultante dessa
avaliação é memorizado por alvo. Qual a natureza do alvo? Os conceitores da linguagem chamam alvo de
lvalue. Esse conceito é similar ao de uma referência em Objective Caml: trata-se de uma entidade que pode guardar
um valor. Por enquanto, a única classe de entidades que vimos que podem ser lvalues são as variáveis.
Segue um pequeno