Índice

Introdução ......................................................................................................................... 2
Objetivos....................................................................................................................... 2
Objetivos gerais:. ...................................................................................................... 2
Objetivos específicos: ............................................................................................... 2
Metodologia .............................................................................................................. 2
Contextualização .............................................................................................................. 3
Funções ......................................................................................................................... 3
Definição de função em C++ .................................................................................... 3
Sintaxe de uma função na linguagem C++ ............................................................... 3
Descrição da sintaxe: ................................................................................................ 4
Declaracao de Funções em C++. .............................................................................. 5
Definição de Função em C++ ................................................................................... 5
Tipo de retorno ............................................................................................................. 5
Retorno Void: ............................................................................................................ 5
Retorno de tipos primitivos: Sintaxe: ....................................................................... 6
Objetos/structs/classes: sintaxe: ............................................................................... 6
Ponteiros: ...................................................................................................................... 7
Chamada da Função...................................................................................................... 7
Parâmetros .................................................................................................................... 8
Tipos de Parâmetros em C++ ....................................................................................... 9
Relação de parâmetros com Tipos de Retorno ........................................................... 14
Escopo das Variáveis: ..................................................................................................... 15
Tipos de funções na linguagem C++ .......................................................................... 17
Boas praticas ............................................................................................................... 23
Conclusão ....................................................................................................................... 26
Referencias bibliográficas .............................................................................................. 27
Introdução

No presente trabalho, abordar-se-á de funções na linguagem de programação C++. Elas

são essenciais para organizar e modularizar o código, evitando repetições e facilitando a
manutenção. Além disso, as funções permitem que o programa seja mais legível e com-
preensível, pois cada função tem um nome e uma finalidade bem definidos.
Para criar e usar funções em C++, é preciso seguir uma sintaxe específica, que consiste
em quatro partes principais: o tipo de retorno, o nome da função, a lista de parâmetros e
o corpo da função. Vamos abordar vários tipos de funções, destacando conceito, sin-
taxe, vantagens e desvantagens e exemplos práticos em C++.

Objetivos

Objetivos gerais: Analisar os conceitos e as aplicações de funções na linguagem de

programação C++, demonstrando como elas podem ser usadas para organizar,
modularizar e otimizar o código.

Objetivos específicos: Definir função em C++, ilustrar as partes que compõem a

sua sintaxe;
• Abordar os diferentes tipos de funções em C++, de acordo com o tipo de retorno, a
lista de parâmetros, a forma de chamada ou a forma de definição;
• Apresentar exemplos práticos de cada tipo de função em C++, ilustrando o seu
funcionamento e as suas vantagens e desvantagens;
• Comparar as funções em C++ com outras linguagens de programação;
• Discutir as boas práticas e as recomendações para o uso de funções em C++, vi-
sando a clareza, a consistência e a eficiência do código;
• Desenvolver um programa aplicando o uso de funções.

Metodologia

A metodologia utilizada na elaboração do trabalho foi guiado no âmbito da pesquisa

qualitativa, que busca compreender as conceções de autores nas suas obras, em torno do
tema a ser estudado.
Contextualização

Funções

Funções são blocos de códigos usados para armazenar instruções de códigos para serem
usados em programas sem precisar escrever novamente blocos de códigos de estrutura
semelhantes.

É uma forma de otimizar um código criando comandos uma só vez para situações que se
necessita usar os mesmos diversas vezes. Havendo essa necessidade de usar o código
diversas vezes não sendo necessariamente parecido em todos os aspetos, mas sim em
aspetos de repetetividade de sintaxe de código comandos. É necessário e suficiente dizer
que escrever mesmas instruções e comandos o tempo inteiro consome maior espaço
tornando o código longo e difícil de interpretar como de manutenciar.

Baseado nisso, verifica-se também que é suficiente inferir que as funções servem de
maneira necessária para otimizar o programa declarando funções ou melhor, declarando
uma função e usá-la tantas vezes achar-se suficiente.

Definição de função em C++

Uma função em C++ é um bloco de código que executa alguma operação. Uma função
pode receber e retornar valores, ou não. As funções são úteis para organizar e reutilizar o
código.

Sintaxe de uma função na linguagem C++

Sintaxe: É conjunto de regras e normas que definem como as instruções de uma

linguagem de programação devem ser escritas. A sintaxe garante que o código seja
validado e executado pelo compilador.

Sintaxe de uma função em c++ :

1. tipo_de_retorno nome_da_funcao(lista_parâmetros) {
2. // Código da função
3. return valor_de_retorno; // Opcional}

Descrição da sintaxe:

Tipo_de_retorno: este é o tipo de dado que a função retorna. Pode ser um tipo
de dado embutido (como ‘int’, ‘float’, ‘char’, etc ), em casos em que a função não
retorna algum valor usa-se o tipo (‘void’) que com detalhes se vai abordar mais
em diante quando se estiver falando dos tipos de retorno.
Nome_da_funcao: este é o identificador da função, ou seja, é o nome que se
atribui a determinada função a fim de que sendo necessário usar essa função seja
chamada pelo nome a que se atribui.
Deve ser único e seguir as regras de nomenclatura de C++.
Lista_parametros: estes são os valores que a função aceita como entrada. São
opcionais e podem ser de qualquer tipo, incluindo tipos de dados embutidos.
Código da função: é o conjunto de instruções que a função executa quando é
chamada;
return valor_de_retorno: esta é a parte em que o programa retorna algo, para o
caso é opcional, podendo retornar um valor ou não. O valor que é retornado
depende do tipo de retorno que foi declarado.

Exemplo de uma função em c++ “aplicando a sintaxe de função em C++”:

1. // declaracao de funcao:
2. int soma(int a, int b){
4. cout << "\ Funcao que retorna Soma de dois numeros";
5. return a+b;}

Essa função também pode ser desenvolvida da maneira como se expressa em baixo:
1. //esta funcao soma pode ser colocada dessa maneira
2. int soma (int a, int b){
3. cout << "\ Funcao que retorna Soma de dois numeros";
5. int resultado= a+b; 10. return resultado;}
Declaracao de Funções em C++.

A declaração de função especifica o nome da função, o tipo de valor de retorno (ou "void"
se a função não retornar nenhum valor) e os parâmetros que a função aceita.
Exemplo de uma declaracao:
1. int soma (int a, int b)

Definição de Função em C++

A definição de função fornece a implementação real da função, ou seja, o código que será
executado quando a função for chamada. A definição inclui o nome da função, o tipo de
retorno, os parâmetros e o corpo da função.
Exemplo de definição de uma função:
int soma(int a, int b) {
return a + b;}

Tipo de retorno

Os tipos indicam qual é o tipo de valor a função irá retornar apos sua execução. São
especificados no início da função. Vários são os tipos de retornos que podem ser usados:

Retorno Void: Os retornos do tipo void não retornam valor algum. São usadas para
realizar ações ou tarefas sem produzir um resultado.

sintaxe:

1. void nome_da_funcao(Lista_parametros) {
Código;}

Exemplo:

1. void imprimirMensagem() {
std::cout << "Esta função não retorna valor." <<
std::endl;}
Retorno de tipos primitivos: Esse tipo de retorno, retorna valores de tipos
primitivos como (char, int, float, double) ou qualquer outro tipo de dados padrão do C++.
Sintaxe:

1. tipo_retorno nome_da_funcao(lista_parametros){
2. código;
3. return valor;}

Exemplo:

1. int soma(int a, int b) {

2. return a + b;}

Objetos/structs/classes: Esse tipo de retorno, retorna objetos de classes, structs ou

classes predefinidas.

Sintaxe:

1. TipoRetorno NomeDaFuncao() {
2. TipoRetorno objeto; // Cria uma instância do objeto
da classe/struct
3. // Realiza alguma inicialização ou processamento no
objeto
4. return objeto; // Retorna o objeto}

Exemplo:

1. class Pessoa {
2. public:
3. std::string nome;
4. int idade;
5.
6. Pessoa(std::string n, int i) : nome(n), idade(i) {}};
8. Pessoa criarPessoa() {
9. Pessoa pessoa("João", 30);
10. return pessoa; }
Ponteiros: Esse tipo de retorno, retorna ponteiros. Útil para retornar um endereço
de memoria para um objeto ou uma matriz alocada dinamicamente.

Sintaxe:
1. tipo_de_ponteiro nome_da_funcao(lista_parametros){
2. Código;}

Exemplo:

1. int* criarArray(int tamanho) {

2. int* arr = new int[tamanho];
3. // Inicializa o array ou faz outras operações
4. return arr;}

Chamada da Função

Significa solicitar a execução de um bloco de código específico que esta encapsulado em

uma função. Quando a função é chamada o programa executa o conjunto de instruções
definidas dentro da função chamada.

Sintaxe:
1. nomeDaFuncao(argumento1, argumento2, ...);

A chamada de função envolve os seguintes passos:

• Identificação da função: a identificação facilita na localização do bloco que se
precisa executar.
• Passagem de argumentos (é opcional): os argumentos são usados para que o
programa realize a tarefa com base nos valores fornecidos.
❖ Os argumentos são os valores ou expressões que são fornecidas a função
quando é chamada.
❖ Os argumentos podem ser passados por valor, referencia ou ponteiros,
dependendo da necessidade e da eficiência da função.
• Execução da função: é a faze que o programa executa o código contido nela, pode
envolver cálculos, operações, manipulações de dados e muito dependendo
especificamente da função.
 • Retorno de valores (é opcional): a função pode retornar algum valor como resultado
de sua execução. Esse valor pode ser usado em seu programa principal ou em outras
partes do código. Esse valor também pode ser usado diretamente como pode se
armazenado numa variável.
Sintaxe de retorno de valores:
1. int resultado = funcaoComRetorno(argumento1,
argumento2);

Parâmetros

Parâmetros em C++ são elementos essenciais em funções, que permitem a

função receba valores para que ela possa executar operações com esses
dados e, possivelmente, retornar um resultado.

O Que São Parâmetros em C++?

Parâmetros são variáveis ou valores que uma função recebe como entrada
quando é chamada. Eles desempenham um papel fundamental na passagem de
informações para funções e na criação de funções genéricas e reutilizáveis.
Em C++, os parâmetros são declarados n a lista de parâmetros da função e
permitem a personalização da ação da função com base nos valores que são
passados a ela.
Sintaxe de Parâmetros em C++:
1. TipoRetorno nomeDaFuncao(TipoParametro1 parametro1,
TipoParametro2 parametro2, ...) {
2. // Corpo da função
3. }

Os parâmetros são usados para fornecer informações à função, permitindo que

ela realize tarefas específicas com base nesses dados. Dentro do corpo da
função, pode-se asseçar e manipular os valores dos parâmetros. Os parâmetros
podem ser utilizados em cálculos, condicionais, loops, chamadas de outras
funções e muito mais, dependendo das necessidades da função.
Tipos de Parâmetros em C++

Em C++, existem três tipos principais de parâmetros:

1. Parâmetros por Valor:
referem-se a uma forma de passar argumentos para uma função ou
método. Quando você passa parâmetros por valor, você está enviando
cópias dos valores originais para a função, e qualquer modificação feita
dentro da função não afeta as variáveis originais fora da função. Em
resumo, os parâmetros por valor tratam os valores como independentes
e isolados do contexto externo.

Isso significa que, quando você chama uma função e passa parâmetros
por valor, qualquer alteração feita nos parâmetros dentro da função não
terá efeito sobre as variáveis originais fora da função.

Exemplo:
1. void duplicar(int& numero) {
numero *= 2; // Modifica a variável original}

2. Parâmetros por referência em c++:

permitem que uma função acesse e modifique diretamente o valor de
uma variável fora da função, em vez de criar uma copia de variável
como é feito com parâmetros por valor.
Para declarar parâmetros por referência usa-se o operador ‘&’ na
declaração do parâmetro e na chamada de função.
Sintaxe de parâmetros por referência:
1. tipo_de_retorno nome_da_funcao(tipo_de_dado
&nome_do_parametro) {
// Corpo da função}

Exemplo:

1. void duplicar(int& numero) {

numero *= 2; // Modifica a variável original}
Regras por se ter em conta em parâmetros por referencia:
• Para declarar uma função com parâmetros por referência, usamos o operador &
na lista de parâmetros da função. Por exemplo:
1. void swap(int &x, int &y); // declaração da função swap
que recebe dois inteiros por referência

• Para chamar uma função com parâmetros por referência, usamos o operador & na
lista de argumentos da chamada da função. Por exemplo:
1. int a = 10;
2. int b = 20;
3. swap(a, b); // chamada da função swap que passa as
variáveis a e b por referência

• Os parâmetros por referência devem ser inicializados no ponto de instanciação,

ou seja, devem receber um valor ou uma variável válida na chamada da função.
Não podemos passar um valor NULL ou uma expressão que não seja uma l-value
(um valor que pode ser atribuído) como parâmetro por referência. Por exemplo:
1. void f(int &x); // declaração da função f que recebe um
inteiro por referência
2. f(5); // erro: não podemos passar um literal como
parâmetro por referência
3. f(NULL); // erro: não podemos passar um valor NULL como
parâmetro por referência
4. f(a + b); // erro: não podemos passar uma expressão que
não seja uma l-value como parâmetro por referência

• Os parâmetros por referência devem sempre referenciar uma variável nomeada ou

anônima (ou seja, não podemos ter uma variável de referência que se refira a nada,
o equivalente a um ponteiro NULL). Uma vez que uma referência é definida para
se referir a uma determinada variável, ela não pode ser reatribuída para se referir
a outra variável. Por exemplo:
1. void f(int &x); // declaração da função f que recebe um
inteiro por referência
2. int a = 10;
3. int b = 20;
4. int &r = a; // declaração de uma variável de referência
r que se refere à variável a
5. f(r); // chamada da função f que passa a referência r
como argumento
6. r = b; // isso não muda a referência r para se referir à
variável b, mas sim atribui o valor de b à variável a
7. f(r); // chamada da função f que ainda passa a referência
r como argumento, mas agora com o valor de a alterado

• Os parâmetros por referência permitem que uma função modifique o valor da va-
riável original que foi passada como argumento, pois ela tem acesso ao seu ende-
reço de memória. Qualquer alteração feita no parâmetro dentro da função é refle-
tida na variável fora da função. Por exemplo:
1. void swap(int &x, int &y); // declaração da função swap
que recebe dois inteiros por referência e troca seus valores
2. int a = 10;
3. int b = 20;
4. cout << "Antes da troca: " << a << " " << b << endl; //
imprime Antes da troca: 10 20
5. swap(a, b); // chamada da função swap que passa as
variáveis a e b por referência e troca seus valores
6. cout << "Depois da troca: " << a << " " << b << endl; //
imprime Depois da troca: 20 10

3. parâmetros por ponteiro:

os parâmetros por ponteiros são uma forma de passar argumentos para
uma função usando ponteiros.
Um Ponteiro é uma variável que armazena o endereço de memoria de
outra variável.
Quando passamos um parâmetro por ponteiro, estamos passando o
endereço da variável origina, não o seu valor. Isso permite que função
modifique o valor da variável original, pois ela tem acesso ao seu
endereço de memoria.
 Para passar um parâmetro por ponteiro usa-se o operador ‘&’ para
obter o endereço da variável e o operador ‘ *’ para acessar o valor
apontado pelo ponteiro.

Sintaxe:
1. TipoDoParâmetro* NomeDoParâmetro

Regras por considerar:

➢ Criação de Funções com Parâmetros Ponteiros :
Para criar uma função com parâmetros ponteiros, você declara a função
com o uso do operador `*` na lista de parâmetros da função. Por
exemplo:
1. void swap(int *x, int *y); // Criação da função swap
que recebe dois ponteiros para inteiros e troca seus valores

➢ Chamada de Funções com Parâmetros Ponteiros:

Para chamar uma função com parâmetros ponteiros, você utiliza o
operador `&` na lista de argumentos da chamada da função. Por
exemplo:
1. int a = 10;
2. int b = 20;
3. swap(&a, &b); // Chamada da função swap que passa os
endereços das variáveis a e b como argumentos

Neste exemplo ao passar `&a` e `&b`, estamos passando os endereços

de memória das variáveis `a` e `b` para a função `swap`, permitindo
que ela acesse e modifique os valores originais.

➢ Reatribuição de Ponteiros dentro de Funções :

Os parâmetros ponteiros podem ser reatribuídos dentro de funções para
apontar para outro endereço de memória. Isso pode ser útil para iterar
sobre um array ou uma lista encadeada, por exemplo. No entanto, é
importante tomar cuidado ao reatribuir ponteiros para garantir que não
 apontem para endereços inválidos ou inexistentes. Aqui estão dois
exemplos: iteração em um array usando ponteiros:
1. void printArray(int *arr, int size) {
2. for (int i = 0; i < size; i++) {
3. cout << *arr << " "; // Imprime o valor
apontado pelo ponteiro arr
4. arr++; // Incrementa o ponteiro arr para
apontar para o próximo elemento do array}}

Iteração em uma lista encadeada usando ponteiros:

1. void printList(Node *head) {
2. while (head != NULL) {
3. cout << head->data << " "; // Imprime o
valor do nó apontado pelo ponteiro head
4. head = head->next; // Reatribui o ponteiro head
para apontar para o próximo nó da lista}}

A reatribuição de ponteiros deve ser feita com cuidado para evitar

vazamentos de memória ou erros de acesso inválido.

➢ Parâmetros Ponteiros com Valor NULL:

Parâmetros ponteiros podem conter um valor NULL, indicando que não
apontam para nenhuma variável válida. Isso pode ser usado para
representar uma condição especial ou um caso base, mas requer que a
função verifique se o ponteiro é NULL antes de acessar o seu valor,
para evitar erros de segmentação. Exemplos:
Verificação de um nó em uma lista encadeada:
1. void printNode(Node *node) {
2. if (node == NULL) {
3. cout << "Node is NULL" << endl; // Condição
especial
4. } else {
5. cout << "Node data: " << node->data << endl; //
Acesso ao valor do nó}}
 Função recursiva que usa um caso base com ponteiro NULL:
1. int sumList(Node *head) {
2. if (head == NULL) {
3. return 0; // Caso base
4. } else {
5. return head->data + sumList(head->next); //
Chamada recursiva}}

O uso de valores NULL permite tratar casos especiais de forma

adequada.

Relação de parâmetros com Tipos de Retorno

Os parâmetros em C++ estão intimamente relacionados com os tipos de

retorno das funções. A função, juntamente com seus parâmetros, forma uma
interface que define como a função é chamada e quais dados ela pode receber.
O tipo de retorno define o tipo de dad o que a função retornará após sua
execução.

A relação entre parâmetros e tipos de retorno é crucial para a funcionalidade

da função e a correta interação com o restante do programa. Uma função bem
projetada deve ter uma correspondência adequada entre seus parâmetros e seu
tipo de retorno para realizar a tarefa desejada de forma eficaz.

A escolha dos tipos de parâmetros e do tipo de retorno é essencial para a

funcionalidade da função e a correta interação com o restante do programa.
Um equilíbrio adequado entre esses elementos é necessário para um código
eficiente e legível.

Em resumo, parâmetros em C++ são fundamentais para passar informações

para funções, permitindo que elas executem tarefas específicas. A escolha dos
tipos de parâmetros e do tipo de retorno é crucial para o sucesso da função e
para a modularização eficiente do código em C++.
Escopo das Variáveis:

São regiões do código onde os nomes de variáveis , funções, classes e outros elementos
podem ser declarados e acessados
➢ Escopo Global:
O escopo global é o escopo mais amplo em um programa C++. Nomes declarados
no escopo global são visíveis em todo o código, a menos que sejam sombreados
por nomes idênticos em escopos mais internos. Nomes no escopo global têm
duração estática, o que significa que eles existem durante toda a execução do
programa. Exemplo:
1. #include <iostream>
2. int x = 10; // Variável global
3. void f() {
4. std::cout << x << std::endl; // Acesso à variável global
x}
5.
6. int main() {
7. std::cout << x << std::endl; // Acesso à variável global
x
8. f(); // Chamada da função f
9. return 0;}

➢ Escopo de Bloco:
O escopo de bloco é introduzido por chaves `{}` e se limita aos blocos delimitados
por essas chaves. Nomes declarados em um escopo de bloco são visíveis apenas
dentro desse bloco e em blocos aninhados a ele. Nomes no escopo de bloco têm
duração automática, existindo apenas enquanto o bloco está sendo executado.
Exemplo:
3. int main() {
4. int x = 10; // Variável local no escopo da função main
5. std::cout << x << std::endl; // Acesso à variável local
x
6. if (x > 0) {
7. int y = 20; // Variável local no escopo do bloco if
 8. std::cout << x << " " << y << std::endl; // Acesso às
variáveis locais x e y
9. }
10. return 0;}

➢ Escopo de Classe:
O escopo de classe é introduzido por uma definição de classe. Nomes declarados
em um escopo de classe são acessíveis somente dentro da classe ou através de
objetos ou ponteiros para objetos dessa classe. Nomes no escopo de classe têm
duração dependente da duração dos objetos da classe. Exemplo:
3. #include <iostream>
4.
5. class Point {
6. public:
7. double x; // Membro de dados no escopo da classe Point
8. double y; // Membro de dados no escopo da classe Point
9.
10. void print() { // Membro de função no escopo da classe
Point
11. std::cout << "(" << x << ", " << y << ")" << std::endl;
// Acesso aos membros de dados x e y
12. }};
13.
14. int main() {
15. Point p1; // Objeto da classe Point
16. p1.x = 1.0; // Acesso ao membro de dados x através do
objeto p1
17. p1.y = 2.0; // Acesso ao membro de dados y através do
objeto p1
18. p1.print(); // Chamada do membro de função print através
do objeto p1
19. return 0;}

➢ Escopo de Namespace:
O escopo de namespace é introduzido por uma definição de namespace. Nomes
declarados em um escopo de namespace são acessíveis apenas dentro do
 namespace ou por meio de qualificadores de escopo (`::`) ou diretivas de uso
(`using`). Nomes no escopo de namespace têm duração estática, existindo durante
toda a execução do programa. Exemplo Escopo de Namespace:
1. #include <iostream>
2.
3. namespace math {
4. const double pi = 3.14; // Constante no escopo do
namespace math
5.
6. double square(double x) { // Função no escopo do
namespace math
7. return x * x;
8. }}
9.
10. int main() {
11. std::cout << math::pi << std::endl; // Acesso à constante
pi usando o qualificador de escopo
12. std::cout << math::square(2.0) << std::endl; // Chamada
da função square usando o qualificador de escopo
13.
14. using namespace math; // Diretiva de uso do namespace
math
15. std::cout << pi << std::endl; // Acesso à constante pi
sem o qualificador de escopo
16. std::cout << square(3.0) << std::endl; // Chamada da
função square sem o qualificador de escopo
17. return 0;}

Tipos de funções na linguagem C++

Em C++ as funções são usadas para diferentes fins, existem os tipos que são mais
aplicáveis para determinado fim, assim, os tipos de funções ilustram a forma como estão
dispostos e podem ser usadas.
1. Funções de retorno void: Essas funções não retornam um valor. São usadas para
executar ações sem produzir um resultado.
Sintaxe:
1. void nomeDaFuncao(parametros) {
2. // Código da função}

Exemplo:
1. void saudacao() {
2. std::cout << "Olá, mundo!" << std::endl;}

2. Funções com retorno: Essas funções retornam um valor após a execução. O tipo de
retorno é especificado na declaração da função.
Sintaxe:
1. tipoDeRetorno nomeDaFuncao(parametros) {
2. // Código da função
3. return valorDeRetorno;}

Exemplo:
1. int soma(int a, int b) {
2. return a + b;}

3. Funções com parâmetros: As funções podem receber parâmetros que são usados
dentro da função. Eles são passados na chamada da função.
Sintaxe:
1. tipoDeRetorno nomeDaFuncao(tipoParametro parametro1,
tipoParametro parametro2, ...) {
2. // Código da função usando parâmetros}

Exemplo:
1. double media(double a, double b) {
2. return (a + b) / 2.0;}

4. Funções sobrecarregadas: Em C++, pode-se definir várias funções com o mesmo

nome, desde que elas tenham parâmetros diferentes. Isso é chamado de sobrecarga de
função.
 Sintaxe:
1. tipoDeRetorno nomeDaFuncao(parametro1) { ... }
2. tipoDeRetorno nomeDaFuncao(parametro1, parametro2)}

Exemplo:
1. int maximo(int a, int b) {
2. return (a > b) ? a : b;}
4.
5. double maximo(double a, double b) {
6. return (a > b) ? a : b;}

5. Funções inline: são aquelas que o compilador tenta otimizar substituindo a chamada
da função pelo código real da função. Elas são úteis para pequenas funções que são
chamadas com frequência, pois reduzem a sobrecarga de chamada de função.
Sintaxe:
1. inline tipoDeRetorno nomeDaFuncao(parametros) {
2. // Código da função}

Exemplo:
inline int dobro(int x) {
return 2 * x;}

6. Funções recursivas: são aquelas que chamam a si mesmas para resolver um problema.
Elas são úteis para resolver problemas que podem ser divididos em sub problemas
semelhantes.
Exemplo de função fatorial recursiva:
1. int fatorial(int n) {
2. if (n <= 1) {
3. return 1;
4. } else {
5. return n * fatorial(n - 1);}}

7. Funções lambda: são funções anônimas e inline que podem ser usadas localmente.
Elas são úteis para passar pequenos blocos de código como argumentos para outras
funções, como algoritmos da STL (Standard Template Library).
 Sintaxe:
1. [captura](parametros) -> tipoDeRetorno {
2. // Código da função}

Exemplo:
1. auto soma = [](int a, int b) -> int {
2. return a + b;};

8. Funções membros: são funções que pertencem a classes em programação orientada

a objetos. Elas operam em dados membros da classe e são essenciais para encapsular
comportamentos e dados.
Sintaxe:
1. class MinhaClasse {
2. public:
3. tipoDeRetorno nomeDaFuncao(parametros) {
4. // Código da função membro}};

Exemplo:
1. class Retangulo {
2. public:
3. double calcularArea() {
4. return largura * altura;}
6. private:
7. double largura;
8. double altura;};

Regras das funções membros:

• Funções membros podem ser definidas dentro ou fora da classe.
• Funções membros definidas dentro da classe são automaticamente inline.
• Funções membros definidas fora da classe devem usar o operador de resolução
de escopo “::”para indicar que pertencem à classe.
• Funções membros podem acessar dados privados da classe.

9. Funções virtuais: são funções membros que podem ser redefinidas em classes
derivadas. Elas são usadas para implementar o polimorfismo em programação orientada
a objetos, permitindo que objetos de diferentes classes se comportem de forma diferente
quando chamam a mesma função.
Sintaxe:
classClasseBase{
public:
virtualtipoDeRetorno nomeDaFuncao(parametros){
// Código da função virtual na classe base}};
classClasseDerivada: publicClasseBase {
public:
tipoDeRetorno nomeDaFuncao(parametros)override{
// Código da função virtual na classe derivada}};
Exemplo:
classAnimal{
public:
virtualvoidfazerSom(){
cout << "Animal faz som"<< endl;}};

classCachorro: publicAnimal {
public:
voidfazerSom()override{
cout << "Cachorro faz au au"<< endl;}};

classGato: publicAnimal {
public:
voidfazerSom()override{
cout << "Gato faz miau"<< endl; }};

10. Funções amigas: são funções que não pertencem a uma classe, mas podem acessar
os membros privados e protegidos dessa classe. Elas são usadas para permitir que outras
funções ou classes tenham acesso especial aos dados internos de uma classe.
Sintaxe:
classMinhaClasse{
// Membros privados e protegidos da classepublic:
friendtipoDeRetorno nomeDaFuncao(parametros); //
Declaração da função amiga};
tipoDeRetorno nomeDaFuncao(parametros){
// Código da função amiga que pode acessar os membros
privados e protegidos da classe}
Exemplo:
classRetangulo{
doublelargura;
doublealtura;
public:
Retangulo(doublel, doublea) : largura(l), altura(a) {}
frienddoublecalcularArea(Retangulo r); // Declaração da
função amiga};

doublecalcularArea(Retangulo r){
returnr.largura * r.altura; // Acesso aos membros
privados largura e altura da classe Retangulo}

11. Funções puras: são funções que não têm efeitos colaterais, ou seja, não alteram o
estado do programa ou dependem de fatores externos. Elas são usadas para garantir a
consistência e a previsibilidade dos resultados, facilitando o teste e a depuração do código.
Exemplo de função impura:
int contador = 0;

int incrementar(){
contador++; // Altera o estado do programa

return contador;
}

int aleatorio(){
return rand(); // Depende de um fator externo (gerador
de números aleatórios)}

Exemplo de função pura:

int somar(int a, int b){
 return a + b; // Não altera o estado do programa nem
depende de fatores externos}

Boas praticas

Criar funções em C++ de acordo com boas práticas é fundamental para escrever código
legível, manutenível e eficiente. Eis algumas diretrizes de boas práticas ao criar funções
em C++:
Nomenclatura Descritiva: Dar nomes descritivos às funções que indiquem claramente
sua finalidade. Evitar nomes genéricos ou abreviações obscuras;
Parâmetros Significativos: Escolher nomes de parâmetros descritivos que expliquem
propósito. Isso torna o código mais legível;
Limitação do Tamanho: Manter as funções curtas e focadas em uma única tarefa. Fun-
ções muito longas são difíceis de entender e manter;
Comentários e Documentação: Incluir comentários ou documentação explicando o que
a função faz, seus parâmetros e valores de retorno. Ferramentas como Doxygen podem
ajudar na geração de documentação;
Evite Efeitos Colaterais: Tentar evitar que suas funções modifiquem variáveis fora de
seu escopo local, a menos que seja necessário. Funções com efeitos colaterais podem
tornar o código mais difícil de depurar e entender;
Retornos Claros: Especificar o tipo de retorno da função de forma clara. Se uma função
não retornar um valor, usar `void` como tipo de retorno;
Validação de Parâmetros: Fazer a validação de parâmetros e manipulação de erros de
forma apropriada. Isso ajuda a evitar comportamento inesperado.
Evite Funções com Muitos Parâmetros: Evitar funções com muitos parâmetros, pois
isso pode tornar a chamada e a manutenção mais complexas. Usar estruturas ou classes
para agrupar parâmetros relacionados;
Usar Referências e Ponteiros Adequadamente: Usar referências ou ponteiros quando
necessário para evitar cópias desnecessárias de objetos grandes. Certificar-se de enten-
der as diferenças entre referências e ponteiros.
Consistência com Convenções da Linguagem: Siguir as convenções de codificação da
linguagem C++ para facilitar a leitura do código por outros desenvolvedores. Por exem-
plo, siguir as convenções de nomenclatura, indentação e formatação.
Evite Funções com Muitas Responsabilidades: Siguir o princípio da "única responsabi-
lidade" ao projetar funções. Cada função deve fazer uma tarefa bem definida e não ten-
tar fazer muitas coisas ao mesmo tempo;
Testes Unitários: Escrever testes unitários. Isso ajuda a garantir que as funções funcio-
nem conforme o esperado e permite detectar regressões quando faz-se alterações no có-
digo.

Comparação de funções no C++ com outras linguagens

❖ C++ vs. C: Em C++, as funções são semelhantes às funções em C. C++ herda a

maioria dos conceitos e sintaxe de funções de C.
C++ permite o uso de sobrecarga de função, que permite ter várias
funções com o mesmo nome, mas com diferentes parâmetros. Isso é
uma extensão em relação ao C.
❖ C++ vs. Java: Em Java, funções são chamadas de métodos e fazem parte de clas-
ses ou objetos. Em C++, funções podem ser globais (fora de classes) ou membros
de classes (métodos).
Java exige que se defina o tipo de retorno, enquanto C++ também
permite funções com tipo de retorno `void` (sem retorno).
Em C++, você pode usar ponteiros de função para passar funções
como argumentos para outras funções. Em Java, isso é mais com-
plexo e requer uso de interfaces.

❖ C++ vs. Python: Python não exige a declaração de tipos de dados para parâmetros
ou retornos de função. C++ requer tipagem estrita.
- Python é interpretado, o que significa que as funções podem ser defini-
das e chamadas dinamicamente. Em C++, o código deve ser compilado
antes da execução.
- Em Python, as funções podem retornar múltiplos valores como uma tu-
pla. Em C++, isso é possível apenas retornando um objeto de uma estru-
tura de dados personalizada.
❖ C++ vs. PHP: PHP é uma linguagem de script usada principalmente para desen-
volvimento web. Funções em PHP podem ser definidas e chamadas de forma
 semelhante a C++, mas são frequentemente usadas para manipular páginas da web
e interagir com bancos de dados.
- Em PHP, você pode definir funções globais e funções de classe (méto-
dos) em classes definidas pelo usuário. C++ também suporta funções glo-
bais e funções de classe.

programa aplicando o uso de funções.

Conclusão

Neste trabalho, abordamos os conceitos e as aplicações de funções na linguagem de pro-

gramação C++. Vimos que as funções são blocos de código que realizam tarefas especí-
ficas e podem ser reutilizados em diferentes partes do programa. Elas são essenciais
para organizar e modularizar o código, evitando repetições e facilitando a manutenção.
Além disso, as funções permitem que o programa seja mais legível e compreensível,
pois cada função tem um nome e uma finalidade bem definidos.

Apresentamos os diferentes tipos de funções em C++, de acordo com o tipo de retorno,

a lista de parâmetros, a forma de chamada ou a forma de definição. Para cada tipo de
função, explicamos o seu conceito, a sua sintaxe, e fornecemos exemplos práticos em
C++. Também comparamos as funções em C++ com as funções em outras linguagens
de programação, destacando as semelhanças e as diferenças.
Discutimos as boas práticas e as recomendações para o uso de funções em C++, visando
a clareza, a consistência e a eficiência do código. Entre essas boas práticas, destacamos
a importância de escolher nomes significativos para as funções, evitar funções muito
longas ou muito curtas, documentar as funções com comentários claros e precisos, testar
as funções com diferentes entradas e saídas, e usar funções padrão da biblioteca sempre
que possível.
As funções são uma das principais ferramentas da programação estruturada e orientada
a objetos, permitindo criar programas mais eficientes, flexíveis e robustos.
 Referencias bibliográficas

I. C++ : como programar / H.M. Deitel, P.J. Deitel ;

tradução Edson Furmankiewicz ; revisão técnica Fábio Lucchini.
II. Introdução à programação orientada a objetos com C++ /
Antonio Mendes da Silva Filho. – Rio de Janeiro: Elsevier, 2010.
III. Apostila de Programação Orientada a Objeto em C++. Versão 0.4.5
IV. Documentação da linguagem C++ (microsoft)
V. Distribuída na forma GFDL
(http://www.gnu.org/licenses/licenses.html#TOCFDL).
VI. — São Paulo: Pearson Prentice Hall, 2006.
VII. Python para Desenvolvedores / Luiz Eduardo Borges Rio de Janeiro, Edição do
Autor, 2010
VIII. pensarpython.incubadora.fapesp.br
IX. C#_como programar/H.M. Deitel;P.j.[outros autores:P.J.Deitel; J Listfield; T.R.
Nieto; C.yaeger; M.Zlatkina], Sao paulo; Person Education, 2003.
X. Introducao à programacao em C(a casa do codigo)
os primeiros passos de um desenvolvedor.