modulus (struct)

Article
10/12/2023

Objet de fonction prédéfini qui effectue l’opération de division de module (operator%) sur ses arguments.

Syntaxe

template <class Type = void>
struct modulus : public binary_function <Type, Type, Type>
{
    Type operator()(const Type& Left, const Type& Right) const;
};

// specialized transparent functor for operator%
template <>
struct modulus<void>
{
  template <class T, class U>
  auto operator()(T&& Left, U&& Right) const
    -> decltype(std::forward<T>(Left) % std::forward<U>(Right));
};

Paramètres

Type, T, U
Tout type qui prend en charge un operator% qui accepte des opérandes des types spécifiés ou inférés.

Left
Opérande gauche de l’opération de modulo. Le modèle non spécifié prend un argument de référence lvalue de type Type. Le modèle spécialisé effectue un transfert parfait des arguments de référence lvalue et rvalue du type T déduit.

Right
Opérande droit de l’opération de modulo. Le modèle non spécifié prend un argument de référence lvalue de type Type. Le modèle spécialisé effectue un transfert parfait des arguments de référence lvalue et rvalue du type déduit U.

Valeur de retour

Résultat de Left % Right. Le modèle spécialisé effectue un transfert parfait du résultat, qui a le type retourné par operator%.

Notes

Le foncteur modulus est limité aux types intégraux pour les types de données de base ou aux types définis par l'utilisateur qui implémentent operator%.

Exemple

// functional_modulus.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

using namespace std;

int main( )
{
   vector <int> v1, v2, v3 ( 6 );
   vector <int>::iterator Iter1, Iter2, Iter3;

   int i;
   for ( i = 1 ; i <= 6 ; i++ )
   {
      v1.push_back( 5 * i );
   }

   int j;
   for ( j = 1 ; j <= 6 ; j++ )
   {
      v2.push_back( 3 * j );
   }

   cout << "The vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   cout << "The vector v2 = ( " ;
   for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
      cout << *Iter2 << " ";
   cout << ")" << endl;

   // Finding the element-wise remainders of the elements of v1 & v2
   transform (v1.begin( ),  v1.end( ), v2.begin( ), v3.begin ( ),
      modulus<int>() );

   cout << "The element-wise remainders of the modular division\n are: ( " ;
   for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
      cout << *Iter3 << " ";
   cout << ")" << endl;
}

The vector v1 = ( 5 10 15 20 25 30 )
The vector v2 = ( 3 6 9 12 15 18 )
The element-wise remainders of the modular division
are: ( 2 4 6 8 10 12 )

Partager via