Exemplos de funções C++

Exemplos De Funcoes C



Uma classe C++ que opera como uma função é chamada de functor. A antiga sintaxe de chamada de função idêntica é usada para invocar os functores. Criamos um objeto que sobrecarrega o “operador()” para gerar um functor. Também podemos dizer que os objetos que podem ser interpretados como uma função ou como um ponteiro de função são chamados de functores. Ao modelar os efeitos funcionais usando os valores dos tipos de dados paramétricos, os “functores” são extremamente convenientes. Neste artigo, o conceito de functor será estudado detalhadamente junto com os códigos C++.

Exemplo 1:

O “iostream” é o arquivo de cabeçalho que incluímos aqui porque temos que utilizar as funções que são declaradas neste arquivo de cabeçalho. O arquivo de cabeçalho “iostream” contém uma declaração de função. O namespace “std” também é adicionado aqui. Em seguida, geramos uma classe chamada “FunctorClass”. Abaixo disso, digitamos “public” que é o construtor público aqui e colocamos a função “operator()”. Em seguida, colocamos uma frase que queremos renderizar na tela na instrução “cout”.

Depois disso, chamamos a função “main()” e a seguir criamos o objeto da “FunctorClass” com o nome “my_functor”. Aqui, chamamos a função “my_functor()” para que ela exiba a instrução que adicionamos abaixo da função “operator()”.







Código 1:



#include
usando espaço para nome padrão ;
aula FunctorClass {
público :
vazio operador ( ) ( ) {
corte << 'A Operação é chamada aqui' ;
}
} ;
interno principal ( ) {
FunctorClass meu_functor ;
meu_functor ( ) ;

retornar 0 ;
}

Saída:



A linha que adicionamos na função “operator()” de “FunctorClass” é exibida aqui utilizando o objeto functor “my_functor”.





Exemplo 2:

Incluímos o arquivo de cabeçalho “iostream” aqui porque algumas declarações de função estão contidas no arquivo de cabeçalho “iostream”. O namespace “std” também é inserido. A seguir, criamos uma classe chamada “SquareClass”.



Abaixo disso, digitamos “public” que é o construtor público e posicionamos a função “operator()” do tipo de dados “int” abaixo dele. Passamos a variável “val” do tipo de dados “int” para esta função “operator()”. Esta função retorna o resultado da multiplicação conforme inserimos “val * val” na função “return()” abaixo da função “operator()”.

Agora, a função “main()” é chamada aqui. Então, o objeto é criado aqui com o nome “s_functor” da classe “SquareFunctor”. Em seguida, utilizamos o “cout” que auxilia na renderização das informações. Depois disso, chamamos o objeto “my_functor()” aqui como uma função e ele retorna o resultado da multiplicação de “5 * 5” conforme adicionamos “5” como parâmetro ao chamá-lo.

Código 2:

#include
usando espaço para nome padrão ;
aula Classe Quadrada {
público :
interno operador ( ) ( interno valor ) {
retornar ( valor * valor ) ;
}
} ;
interno principal ( ) {
SquareClass s_functor ;
corte << 'O quadrado do valor dado é' << fim ;
corte << função_s ( 5 ) ;

retornar 0 ;
}

Saída:

Obtemos a saída depois de chamar o objeto “my_functor” da classe “SqaureClass” como a função “my_functor()” e depois passar “5”. Obtemos “25” como o quadrado do número “5”.

Exemplo 3:

O arquivo de cabeçalho “iostream” está incluído aqui porque contém uma declaração de função, e o namespace “std” é introduzido posteriormente. A classe “ProductFunctor” é então criada. O construtor público, “public”, é digitado abaixo dele e a função “operator()” do tipo de dados “int” é posicionada abaixo dele. Substituímos esta função aqui e passamos dois parâmetros para ela: “int var1” e “int var2”.

Em seguida, utilizamos o “retorno” abaixo e multiplicamos as duas variáveis ​​que retornam o resultado da multiplicação de ambos os números “var1 * var2”. A função “main()” é então chamada aqui e geramos o objeto de classe com o nome “P_functor” da classe “ProductFunctor”. Em seguida, inicializamos uma nova variável com o nome “pro_result” e atribuímos o objeto “P_functor” como a função “P_functor()” após chamá-lo.

Passamos “28” e “63” como parâmetro. Isso irá multiplicar os dois valores e salvar o resultado na variável “pro_result” que imprimimos abaixo usando o ”cout” e passando “pro_result” nela.

Código 3:

#include
usando espaço para nome padrão ;
aula ProdutoFunctor {
público :
interno operador ( ) ( interno var1, interno var2 ) {
retornar var1 * var2 ;
}
} ;
interno principal ( ) {
ProdutoFunctor P_functor ;
interno resultado_produto = Função_P ( 28 , 63 ) ;
corte << 'O produto é:' << resultado_produto << fim ;
retornar 0 ;
}

Saída:

Obtemos o produto depois de chamar o objeto “P_functor” como a função “P_functor()” e passar os valores para ele. O produto desses valores é “1764”.

Exemplo 4:

O “GreetingFunctorClass” é gerado nesta instância. Em seguida, inserimos o construtor “público” e substituímos a função “operador()” neste construtor “público”. Digitamos “Olá! Sou um programador C++ aqui” depois de colocar o “cout” abaixo da função “operator()”.

Agora em diante, chamamos “main()”. Criamos o “g_functor” aqui como o objeto de “GreetingFunctorClass” e então chamamos esse objeto “g_functor” como a função “g_functor()”. Isso fornece o resultado que adicionamos na função “operator()” ao substituí-la.

Código 4:

#include
usando espaço para nome padrão ;
usando espaço para nome padrão ;
aula SaudaçãoFunctorClass {
público :
vazio operador ( ) ( ) {
corte << 'Olá! Sou programador C++ aqui' ;
}
} ;
interno principal ( ) {
SaudaçãoFunctorClass g_functor ;
função_g ( ) ;
retornar 0 ;
}

Saída:

Aqui, podemos notar que a instrução que adicionamos quando substituímos a função “operator()” em nosso código é exibida aqui quando chamamos o objeto de classe como uma função.

Exemplo 5:

O “bits/stdc++.h” está incluído desta vez, pois contém todas as declarações de função necessárias. Então, o namespace “std” é colocado aqui. A classe que criamos aqui é a classe “incrementFunctor”. Em seguida, criamos um construtor “privado” e inicializamos a variável “int_num” com o tipo de dados “int”.

Abaixo dele, o construtor “público”, colocamos o “incrementFunctor” e passamos “int n1” dentro dele. Em seguida, digitamos “int_num(n1)” após colocar o “:”. Em seguida, substituímos a função que é a função “operator()” do tipo de dados “int” e declaramos “int arrOfNum” aqui. Em seguida, usamos o “return” e inserimos “int_num + arrOfNum”. Agora, isso incrementa os valores de “arrOfNum”, adiciona o valor “int_num” a eles e os retorna aqui.

Depois de invocar “main()”, inicializamos “arrOfNum” e atribuímos diferentes valores inteiros aqui. Em seguida, a variável “n1” é inicializada onde adicionamos a função “sizeof” como “sizeof(arrOfNum)/sizeof(arrOfNum[0])”. Depois disso, o “additionNumber” é inicializado com “3”. Agora, utilizamos a função “transform()”. Este “transform()” é o mesmo que criar o objeto da classe “increamentFunctor” e depois chamar seu objeto. Depois disso, usamos o loop “for” e depois “cout” o “arrOfNum[i]”.

Código 5:

#incluir
usando espaço para nome padrão ;
aula incrementoFunctor
{
privado :
interno núm_int ;
público :
incrementoFunctor ( interno n1 ) : núm_int ( n1 ) { }
interno operador ( ) ( interno arrOfNum ) const {
retornar núm_int + arrOfNum ;
}
} ;
interno principal ( )
{
interno arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
interno n1 = tamanho de ( arrOfNum ) / tamanho de ( arrOfNum [ 0 ] ) ;
interno número de adição = 3 ;
transformar ( arrOfNum, arrOfNum + n1, arrOfNum, incrementFunctor ( número de adição ) ) ;

para ( interno eu = 0 ; eu < n1 ; eu ++ )
corte << arrOfNum [ eu ] << ' ' ;
}

Saída:

O resultado do código é mostrado aqui em que “incrementFunctor” é o “Functor” que é utilizado como função.

Exemplo 6:

Neste código, utilizamos o functor “maior” predefinido. Aqui, incluímos quatro arquivos de cabeçalho diferentes conforme os necessitamos em nosso código, porque as funções ou métodos que precisamos em nosso código são declarados neles. Então, após adicionar “std” e chamar “main()”, inicializamos o vetor “myIntegerVector”. Inserimos alguns valores não classificados neste vetor. Abaixo disso, aplicamos a função “sort” para classificar esses valores vetoriais.

Quando utilizamos esta função, ela classifica os valores em ordem crescente. Mas utilizamos o “maior” aqui, que é a função predefinida em C++ que fornece o resultado da classificação de maneira decrescente. Depois disso, exibimos os valores classificados com o auxílio do loop “for” e depois “cout”.

Código 6:

#include
#incluir
#incluir
#include
usando espaço para nome padrão ;

interno principal ( ) {
vetor < interno > meuIntegerVetor = { 13 , vinte e um , 19 , 44 , 32 , 42 , 9 , 6 } ;
organizar ( meuIntegerVector. começar ( ) , meuIntegerVector. fim ( ) , maior < interno > ( ) ) ;
para ( interno número_vec : meuIntegerVetor ) {
corte << número_vec << '' ;
}
retornar 0 ;
}

Saída:

Todos os valores do vetor são ordenados de forma decrescente com o auxílio do functor predefinido em C++ que é o functor “maior”, e sua definição está disponível no arquivo de cabeçalho “funcional”.

Conclusão

O conceito de “functor C++” é profundamente explorado neste artigo. Estudamos que um objeto pode ser invocado como uma função para sobrecarregar uma função chamada “operador()”. Isso é conhecido como funtor. O acesso público deve ser fornecido para que a sobrecarga do “operador()” seja utilizada conforme pretendido. Ilustramos diversos exemplos em que utilizamos os “functors” e o “functor” predefinido em nosso código.