Se recomienda usar Visual Studio 2017

modulus (Struct)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

Un objeto de función predefinido que realiza la operación de división del módulo ( operator%) sobre sus argumentos.

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));

 };

Parámetros

Type, T, U
Cualquier tipo que admite un operator% que toma operandos de los tipos especificados o deducidos.

Left
Operando izquierdo de la operación de módulo. La plantilla no especializada toma un argumento de referencia de valor L de tipo Type. La plantilla especializada realiza el reenvío directo de los argumentos de referencia de valor L y valor R del tipo deducido T.

Right
Operando derecho de la operación de módulo. La plantilla no especializada toma un argumento de referencia de valor L de tipo Type. La plantilla especializada realiza el reenvío directo de los argumentos de referencia de valor L y valor R del tipo deducido U.

El resultado de Left``%``Right. La plantilla especializada realiza el reenvío directo del resultado, que tiene el tipo devuelto por operator%.

El functor de modulus está limitado a tipos enteros para los tipos de datos básicos, o a tipos definidos por el usuario que implementan el operator%.

// 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;  
}  
/* Output:  
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 )  
 */  

Encabezado:<>>

Espacio de nombres: std

Seguridad para subprocesos en la biblioteca estándar de C++
Biblioteca de plantillas estándar

Mostrar: