Menu

Funções em C ++ com tipos e exemplos

functions c with types examples

Experimente Nosso Instrumento Para Eliminar Problemas

Tipos de funções em C ++ junto com seus usos.

Em nossos tutoriais anteriores até agora, vimos os vários conceitos em C ++ como variáveis, classes de armazenamento, operadores, arrays, strings, etc.

Neste tutorial, avançaremos e discutiremos o conceito de funções. As funções também são chamadas de métodos, sub-rotinas ou procedimentos.

=> Leia a extensa série de tutoriais de treinamento em C ++ aqui.

FUNÇÕES EM C ++

O que você aprenderá:

Como definimos uma função?

Uma função é um conjunto de instruções que são reunidas para realizar uma tarefa específica. Podem ser instruções que executam algumas tarefas repetidas ou instruções que executam algumas tarefas especiais, como impressão, etc.

Um uso de ter funções é simplificar o código dividindo-o em unidades menores chamadas funções. Outra ideia por trás do uso de funções é que isso nos impede de escrever o mesmo código repetidamente. Temos apenas que escrever uma função e chamá-la como e quando necessário, sem ter que escrever o mesmo conjunto de instruções repetidas vezes.

Tipos de funções em C ++

Em C ++, temos dois tipos de funções, conforme mostrado abaixo.

Tipos de funções em C ++

Funções integradas

As funções integradas também são chamadas de funções de biblioteca. Essas são as funções fornecidas pelo C ++ e não precisamos escrevê-las nós mesmos. Podemos usar essas funções diretamente em nosso código.

Essas funções são colocadas nos arquivos de cabeçalho do C ++. Por exemplo ,, são os cabeçalhos que possuem funções matemáticas embutidas e funções de string, respectivamente.

Vejamos um exemplo de uso de funções integradas em um programa.

#include #include using namespace std; int main() { string name; cout << 'Enter the input string:'; getline (std::cin, name); cout << 'String entered: ' << name << '! '; int size = name.size(); cout<<'Size of string : '<

Resultado:

Digite a string de entrada: Ajuda de teste de software
String inserida: Ajuda para teste de software!
Tamanho da corda: 21

Aqui estamos usando os cabeçalhos e. Os tipos de dados e outras funções de entrada / saída são definidos na biblioteca. Funções de string usadas como getline, size são uma parte do cabeçalho.

Funções definidas pelo usuário

C ++ também permite que seus usuários definam suas próprias funções. Estas são as funções definidas pelo usuário. Podemos definir as funções em qualquer lugar do programa e, em seguida, chamar essas funções de qualquer parte do código. Assim como as variáveis, deve ser declarado antes de usar, as funções também precisam ser declaradas antes de serem chamadas.

Vamos discutir as funções definidas pelo usuário em detalhes.

A sintaxe geral para funções definidas pelo usuário (ou simplesmente funções) é fornecida a seguir:

return_type functionName(param1,param2,….param3) { Function body; }

Como mostrado acima, cada função tem:

  • Tipo de retorno: É o valor que as funções retornam à função de chamada após realizar uma tarefa específica.
  • functionName : Identificador usado para nomear uma função.
  • Lista de parâmetros: Denotado por param1, param2,… paramn na sintaxe acima. Esses são os argumentos que são passados ​​para a função quando uma chamada de função é feita. A lista de parâmetros é opcional, ou seja, podemos ter funções que não possuem parâmetros.
  • Corpo da função: Um grupo de afirmações que realizam uma tarefa específica.

Como já mencionado, precisamos ‘declarar’ uma função antes de usá-la.

Declaração de Função

Uma declaração de função informa ao compilador sobre o tipo de retorno da função, o número de parâmetros usados ​​pela função e seus tipos de dados. Incluindo os nomes dos parâmetros na função, a declaração é opcional. A declaração de função também é chamada de protótipo de função.

Fornecemos alguns exemplos da declaração de função abaixo para sua referência.

int sum(int, int);

A declaração acima é de uma função ‘soma’ que leva dois inteiros como parâmetros e retorna um valor inteiro.

void swap(int, int);

Isso significa que a função de troca recebe dois parâmetros do tipo int e não retorna nenhum valor e, portanto, o tipo de retorno é nulo.

void display();

O display de função não aceita nenhum parâmetro e também não retorna nenhum tipo.

Definição de Função

Uma definição de função contém tudo o que uma declaração de função contém e, além disso, também contém o corpo da função entre colchetes ({}).

Além disso, ele também deve ter parâmetros nomeados. Quando a função é chamada, o controle do programa passa para a definição da função para que o código da função possa ser executado. Quando a execução da função termina, o controle retorna ao ponto onde a função foi chamada.

Para a declaração da função de troca acima, a definição é a seguinte:

void swap(int a, int b){ b = a + b; a = b - a; b = b - a; }

Observe que a declaração e a definição de uma função podem andar juntas. Se definirmos uma função antes de fazer referência a ela, não haverá necessidade de uma declaração separada.

Tomemos um exemplo de programação completo para demonstrar uma função.

#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<' After swapping: '; cout<<'a = '< Chamando uma função

Quando temos uma função em nosso programa, dependendo do requisito, precisamos chamar ou invocar essa função. Somente quando a função é chamada ou invocada, a função executará seu conjunto de instruções para fornecer os resultados desejados.

A função pode ser chamada de qualquer lugar no programa. Pode ser chamado a partir da função principal ou de qualquer outra função se o programa estiver usando mais de uma função. A função que chama outra função é chamada de “Função de chamada”.

No exemplo acima de troca de números, a função de troca é chamada na função principal. Portanto, a função principal se torna a função de chamada.

Parâmetros formais e reais

Já vimos que podemos ter parâmetros para as funções. Os parâmetros da função são fornecidos na definição da função como uma lista de parâmetros que segue o nome da função. Quando a função é chamada, temos que passar os valores reais desses parâmetros para que, usando esses valores reais, a função possa realizar sua tarefa.

Os parâmetros que são definidos na definição da função são chamados Parâmetros Formais . Os parâmetros na chamada de função que são os valores reais são chamados Parâmetros reais.

No exemplo acima de troca de números, escrevemos os comentários para parâmetros formais e reais. Na função de chamada, ou seja, principal, o valor de dois inteiros é lido e passado para a função de troca. Esses são os parâmetros reais.

Podemos ver as definições desses parâmetros na primeira linha da definição da função. Esses são os parâmetros formais.

Observe que o tipo de argumento formal e real deve corresponder. A ordem dos parâmetros formais e reais também deve corresponder.

Valores Retornados

Depois que a função executa sua tarefa pretendida, ela deve retornar o resultado para a função de chamada. Para isso, precisamos do tipo de retorno da função. A função pode retornar um único valor para a função de chamada. O tipo de retorno da função é declarado junto com o protótipo da função.

Vamos dar um exemplo de adição de dois números para demonstrar os tipos de retorno.

#include using namespace std; int sum(int a, int b){ return (a+b); } int main() { int a, b, result; cout<>a>>b; result = sum(a,b); cout<<' Sum of the two numbers : '<

Resultado:

Digite os dois números a serem adicionados: 11 11

Soma dos dois números: 22

No exemplo acima, temos uma função sum que recebe dois parâmetros inteiros e retorna um tipo inteiro. Na função principal, lemos dois inteiros da entrada do console e os passamos para a função soma. Como o tipo de retorno é um inteiro, temos uma variável de resultado no LHS e RHS é uma chamada de função.

Quando uma função é executada, a expressão (a + b) retornada pela função sum é atribuída à variável de resultado. Isso mostra como o valor de retorno da função é usado.

Funções de Vazio

Vimos que a sintaxe geral da função requer a definição de um tipo de retorno. Mas se no caso de termos uma função que não retorna nenhum valor, nesse caso, o que especificamos como o tipo de retorno? A resposta é que utilizamos o tipo sem valor “void” para indicar que a função não retorna um valor.

Nesse caso, a função é chamada de 'função nula' e seu protótipo será como

void functionName (param1, param2,… .param 3);

Observação : É considerado uma boa prática incluir uma declaração 'return;' no final da função vazio para maior clareza.

Passando Parâmetros para Funções

Já vimos o conceito de parâmetros reais e formais. Também sabemos que os parâmetros reais passam valores para uma função que é recebida pelos parâmetros de formato. Isso é chamado de passagem de parâmetros.

Em C ++, temos certas maneiras de passar parâmetros, conforme discutido abaixo.

Passe por valor

No programa para trocar dois inteiros que discutimos anteriormente, vimos que apenas lemos os inteiros ‘a’ e ‘b’ em principal e os passamos para a função de troca. Esta é a técnica de passagem por valor.

Na técnica de passagem por valor de passagem de parâmetro, as cópias dos valores dos parâmetros reais são passadas para os parâmetros formais. Devido a isso, os parâmetros reais e formais são armazenados em diferentes locais da memória. Portanto, as alterações feitas nos parâmetros formais dentro da função não refletem fora da função.

Podemos entender isso melhor visitando mais uma vez a troca de dois números.

#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<' After swapping inside Swap: '; cout<<'a = '< Passe por referência

Passar por referência é outra técnica usada pelo C ++ para passar parâmetros para funções. Nessa técnica, em vez de passar cópias de parâmetros reais, passamos referências a parâmetros reais.

Observação: As referências nada mais são do que apelidos de variáveis ​​ou, em palavras simples, é outro nome dado a uma variável. Portanto, uma variável e sua referência compartilham a mesma localização na memória. Aprenderemos as referências em detalhes em nosso tutorial subsequente.

Na técnica de passagem por referência, usamos essas referências de parâmetros reais e, como resultado, as alterações feitas nos parâmetros formais na função são refletidas de volta para a função de chamada.

Modificamos nossa função de troca para que nossos leitores entendam melhor o conceito.

#include #include using namespace std; void swap(int &a, int &b){ int temp = a; a = b; b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '<

Portanto, as alterações feitas nos parâmetros formais na função de troca refletem na função principal e obtemos os valores trocados.

Ponteiro de passagem

Em C ++, também podemos passar parâmetros para funcionar usando variáveis ​​de ponteiro. A técnica de passagem por ponteiro produz os mesmos resultados que a passagem por referência. Isso significa que os parâmetros formais e reais compartilham os mesmos locais de memória e as alterações feitas na função são refletidas na função de chamada.

A única diferença é que em uma passagem por referência lidamos com referências ou apelidos de parâmetros, enquanto em uma técnica de passagem por ponteiro usamos variáveis ​​de ponteiro para passar os parâmetros.

As variáveis ​​de ponteiro diferem com as referências nas quais as variáveis ​​de ponteiro apontam para uma determinada variável e, ao contrário das referências, podemos alterar a variável para a qual ela aponta. Exploraremos os detalhes do ponteiro em nossos tutoriais subsequentes.

Apresentamos a troca de dois inteiros novamente para demonstrar a técnica Pass by Pointer.

#include #include using namespace std; void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '< Parâmetros padrão

Em C ++, podemos fornecer valores padrão para parâmetros de função. Neste caso, quando invocamos a função, não especificamos parâmetros. Em vez disso, a função usa os parâmetros padrão que são fornecidos no protótipo.

O exemplo a seguir demonstra o uso de parâmetros padrão.

#include #include using namespace std; int mathoperation(int a, int b = 3, int c = 2){ return ((a*b)/c); } int main() { int a,b,c; cout<>a>>b>>c; cout<

Resultado:

Insira os valores para a, b e c: 10 4 6

Chamada para operação matemática com 1 arg: 15
Chamada para operação matemática com 2 arg: 20
Chamada para operação matemática com 3 arg: 6

Conforme mostrado no exemplo de código, temos uma função ‘mathoperation’ que leva três parâmetros, dos quais fornecemos valores padrão para dois parâmetros. Então, na função principal, chamamos essa função três vezes com uma lista de argumentos diferente.

A primeira chamada é com apenas um argumento. Nesse caso, os outros dois argumentos terão valores padrão. A próxima chamada é com dois argumentos. Nesse caso, o terceiro argumento terá um valor padrão. A terceira chamada é com três argumentos. Nesse caso, como fornecemos todos os três argumentos, os valores padrão serão ignorados.

Observe que, ao fornecer parâmetros padrão, sempre iniciamos do parâmetro mais à direita. Além disso, não podemos ignorar um parâmetro intermediário e fornecer um valor padrão para o próximo parâmetro.

Agora, vamos passar para alguns conceitos relacionados a funções especiais que são importantes do ponto de vista do programador.

Parâmetros Const

Também podemos passar parâmetros constantes para funções usando a palavra-chave ‘const’. Quando um parâmetro ou referência é constante, não pode ser alterado dentro da função.

Observe que não podemos passar um parâmetro const para um parâmetro formal não const. Mas podemos passar os parâmetros const e não const para um parâmetro formal const.

Da mesma forma, também podemos ter o tipo de retorno const. Neste caso, também, o tipo de retorno não pode ser modificado.

Vejamos um exemplo de código que usa referências const.

#include #include using namespace std; int addition(const int &a, const int &b){ return (a+b); } int main() { int a,b; cout<>a>>b; cout<<'a = '<

Resultado:

Digite os dois números a serem trocados: 22 33
a = 2 b = 33
Resultado da adição: 55

No programa acima, temos parâmetros formais const. Observe que os parâmetros reais são variáveis ​​não constantes comuns que passamos com sucesso. Como os parâmetros formais são constantes, não podemos modificá-los dentro da função. Portanto, apenas realizamos a operação de adição e retornamos o valor.

Se tentarmos modificar os valores de a ou b dentro da função, o compilador emitirá um erro.

Funções Inline

Sabemos que, para fazer uma chamada de função, internamente envolve um compilador que armazena o estado do programa em uma pilha antes de passar o controle para a função.

Quando a função retorna, o compilador precisa recuperar o estado do programa e continuar de onde saiu. Isso representa uma sobrecarga. Portanto, em C ++ sempre que temos uma função que consiste em poucas instruções, há um recurso que permite sua expansão embutida. Isso é feito tornando uma função embutida.

Portanto, funções inline são as funções que são expandidas em tempo de execução, economizando esforços para chamar a função e fazer as modificações da pilha. Mas mesmo se fizermos uma função como embutida, o compilador não garante que ela será expandida em tempo de execução. Em outras palavras, é completamente dependente do compilador tornar a função embutida ou não.

Alguns compiladores detectam funções menores e as expandem em linha, mesmo se não forem declaradas em linha.

A seguir está um exemplo de uma função embutida.

inline int addition(const int &a,const int &b){ return (a+b); }

Conforme mostrado acima, precedemos a definição da função com uma palavra-chave “inline” para tornar uma função inline.

Usando Structs em Funções

Podemos passar variáveis ​​de estrutura como parâmetros para funcionar de maneira semelhante à qual passamos variáveis ​​comuns como parâmetros.

Isso é mostrado no exemplo a seguir.

#include #include using namespace std; struct PersonInfo { int age; char name(50); double salary; }; void printStructInfo(PersonInfo p) { cout<<'PersonInfo Structure:'; cout<<' Age:'< p.age; cout <> p.salary; printStructInfo(p); }

Resultado:

Digite o nome: Vedang
Insira a idade: 22
Digite o salário: 45.000,00
Estrutura PersonInfo:
Idade: 22
Nome: Vedang
Salário: 45.000

Usando structs em funções - Saída

Conforme mostrado no programa acima, passamos uma estrutura para funcionar de maneira semelhante a outras variáveis. Lemos valores para membros da estrutura da entrada padrão e, em seguida, passamos uma estrutura para uma função que exibe a estrutura.

Conclusão

Isso era tudo sobre o básico das funções em C ++.

Exploraremos mais sobre as funções estáticas em C ++ em nossos próximos tutoriais.

=> Verifique a série de treinamento C ++ GRATUITA completa aqui.

Leitura recomendada

^