std::mem_fn

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Objetos función

Envoltorios de funciones function (C++11) move_only_function (C++23) mem_fn (C++11) bad_function_call (C++11)	Aplicación parcial de funciones bind_front (C++20) bind (C++11) is_bind_expression (C++11) is_placeholder (C++11) _1, _2, _3, ... (C++11)
Invocación de funciones invokeinvoke_r (C++17)(C++23) Objeto función identidad identity (C++20)	Envoltorios de referencias reference_wrapper (C++11) refcref (C++11)(C++11) unwrap_referenceunwrap_ref_decay (C++20)(C++20)
Envoltorios de operadores plus minus negate multiplies divides modulus bit_and bit_or bit_not (C++14) bit_xor equal_to not_equal_to greater less greater_equal less_equal logical_and logical_or logical_not	Envoltorios de operador transparentes plus<> (C++14) minus<> (C++14) negate<> (C++14) multiplies<> (C++14) divides<> (C++14) modulus<> (C++14) bit_and<> (C++14) bit_or<> (C++14) bit_not<> (C++14) bit_xor<> (C++14) equal_to<> (C++14) not_equal_to<> (C++14) greater<> (C++14) less<> (C++14) greater_equal<> (C++14) less_equal<> (C++14) logical_and<> (C++14) logical_or<> (C++14) logical_not<> (C++14)
Negadores not_fn (C++17) Buscadores default_searcher (C++17) boyer_moore_searcher (C++17) boyer_moore_horspool_searcher (C++17)	Comparadores restringidos ranges::equal_to (C++20) ranges::not_equal_to (C++20) ranges::greater (C++20) ranges::less (C++20) ranges::greater_equal (C++20) ranges::less_equal (C++20) compare_three_way (C++20)
Vinculadores y adaptadores antiguos
unary_function (hasta C++17) binary_function (hasta C++17) ptr_fun (hasta C++17) pointer_to_unary_function (hasta C++17) pointer_to_binary_function (hasta C++17) mem_fun (hasta C++17) mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (hasta C++17)(hasta C++17)(hasta C++17)(hasta C++17) not1 (hasta C++20) not2 (hasta C++20)	binder1stbinder2nd (hasta C++17)(hasta C++17) bind1stbind2nd (hasta C++17)(hasta C++17) mem_fun_ref (hasta C++17) mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (hasta C++17)(hasta C++17)(hasta C++17)(hasta C++17) unary_negate (hasta C++20) binary_negate (hasta C++20)

 

<tbody> </tbody>

Definido en el archivo de encabezado <functional>
template< class R, class T > /*unspecified*/ mem_fn(R T::* pm);	(1)	(desde C++11)
template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...)); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile &&);	(2)	(c + 11, pero defecto)

std::mem_fn Función plantilla genera objetos envolventes para saber cómo dirigirse a los miembros, que puede almacenar, copiar, e invocar un puntero al miembro. Ambas referencias e indicadores (incluyendo punteros inteligentes) a un objeto se puede utilizar cuando se invoca una std::mem_fn .

Original:

Function template std::mem_fn generates wrapper objects for pointers to members, which can store, copy, and invoke a pointer to member. Both references and pointers (including smart pointers) to an object can be used when invoking a std::mem_fn.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Las sobrecargas (2) se presentan como defecto .

Original:

The overloads (2) are reported as defect.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

El resolution, que recientemente ha sido votada como "Tentativamente Ready" se propone eliminar todas las sobrecargas (2) .

Original:

The resolution, which has recently been voted "Tentatively Ready" proposes to remove all the overloads (2).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Esto romperá algo de código, véase el ejemplo 3 .

Original:

This will break some code, see Example 3.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Parámetros

pm

-

puntero al miembro que va a ser envuelto Original: pointer to member that will be wrapped The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Valor de retorno

std::mem_fn devuelve una envoltura llamada de tipo no especificado que tiene los miembros siguientes:

Original:

std::mem_fn returns an call wrapper of unspecified type that has the following members:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

std :: mem_fn

Original:

std::mem_fn

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Return type

Member types

tipo Original: type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.	definition
result_type	el tipo de retorno de pm pm si es un puntero a función miembro, no está definido para el puntero a objeto miembro Original: the return type of pm if pm is a pointer to member function, not defined for pointer to member object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
argument_type	T*, posiblemente cv-calificado, si pm es un puntero a función miembro sin argumentos Original: T*, possibly cv-qualified, if pm is a pointer to member function taking no arguments The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
first_argument_type	T* pm si es un puntero a función miembro toma un argumento Original: T* if pm is a pointer to member function taking one argument The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
second_argument_type	T1 pm si es un puntero a función miembro toma un argumento de tipo T1 Original: T1 if pm is a pointer to member function taking one argument of type T1 The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Member function

operator()

invoca al destino de un objeto determinado, con parámetros opcionales Original: invokes the target on a specified object, with optional parameters The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (función miembro pública)

Excepciones

Ninguno .

Original:

None.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Ejemplo 1

Utilice mem_fn para almacenar y ejecutar una función miembro y un objeto miembro:

Original:

Use mem_fn to store and execute a member function and a member object:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Ejecuta este código

#include <functional>
#include <iostream>

struct Foo {
  void display_greeting() {
    std::cout << "Hello, world.\n";
  }
  void display_number(int i) {
    std::cout << "number: " << i << '\n';
  }
  int data = 7;
};

int main() {
  Foo f;

  auto greet = std::mem_fn(&Foo::display_greeting);
  greet(f);

  auto print_num = std::mem_fn(&Foo::display_number);
  print_num(f, 42);

  auto access_data = std::mem_fn(&Foo::data);
  std::cout << "data: " << access_data(f) << '\n';
}

Salida:

Hello, world.
number: 42
data: 7

Ejemplo 2

Pasar una función miembro para std::transform para crear una secuencia de números:

Original:

Pass a member function to std::transform to create a sequence of numbers:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Ejecuta este código

#include <iostream>
#include <functional>
#include <iterator>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>

int main()
{
    std::vector<std::string> words = {"This", "is", "a", "test"};
    std::vector<std::unique_ptr<std::string>> words2;
    words2.emplace_back(new std::string("another"));
    words2.emplace_back(new std::string("test"));

    std::vector<std::size_t> lengths;
    std::transform(words.begin(),
                   words.end(),
                   std::back_inserter(lengths),
                   std::mem_fn(&std::string::size)); // uses references to strings
    std::transform(words2.begin(),
                   words2.end(),
                   std::back_inserter(lengths),
                   std::mem_fn(&std::string::size)); // uses unique_ptr to strings

    std::cout << "The string lengths are ";
    for(auto n : lengths) std::cout << n << ' ';
    std::cout << '\n';
}

Salida:

The string lengths are 4 2 1 4 7 4

Ejemplo 3

Ejecuta este código

#include <functional>

struct X {
  int x;

        int& easy()      {return x;}
        int& get()       {return x;}
  const int& get() const {return x;}
};


int main(void)
{
    auto a = std::mem_fn        (&X::easy); // no problem at all
//  auto b = std::mem_fn<int&  >(&X::get ); // no longer works with new specification
    auto c = std::mem_fn<int&()>(&X::get ); // works with both old and new specification
    auto d = [] (X& x) {return x.get();};   // another approach to overload resolution
}

Ver también

function (C++11)	Envuelve un objeto que puede ser llamado a cualquier tipo con la signatura de llamada a función especificada. (plantilla de clase)
bind (C++11)	Vincula uno o más argumentos a un objeto función. (plantilla de función)