Espaços nominais
Variantes
Acções

std::mem_fn

Da cppreference.com
< cpp‎ | utility‎ | functional

 
 
Biblioteca de utilitários
Digite apoio (basic types, RTTI, type traits)
Gerenciamento de memória dinâmica
De tratamento de erros
Utilidades do programa
Variadic funções
Data e hora
Objetos de função
initializer_list(C++11)
bitset
hash(C++11)
Os operadores relacionais
Original:
Relational operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rel_ops::operator!=
rel_ops::operator>
rel_ops::operator<=
rel_ops::operator>=
Pares e tuplas
Original:
Pairs and tuples
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pair
tuple(C++11)
piecewise_construct_t(C++11)
piecewise_construct(C++11)
Troque, avançar e avançar
Original:
Swap, forward and move
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
swap
forward(C++11)
move(C++11)
move_if_noexcept(C++11)
declval(C++11)
 
Objetos de função
Invólucros de função
Original:
Function wrappers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
function(C++11)
mem_fn(C++11)
bad_function_call(C++11)
Ligar
Original:
Bind
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
bind(C++11)
is_bind_expression(C++11)
is_placeholder(C++11)
_1, _2, _3, ...(C++11)
Invólucros de referência
Original:
Reference wrappers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
reference_wrapper(C++11)
ref
cref
(C++11)
(C++11)
Invólucros operador
Original:
Operator wrappers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Negadores
Original:
Negators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Obsoleta ligantes e adaptadores
Original:
Deprecated binders and adaptors
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
unary_function(obsoleta)
binary_function(obsoleta)
ptr_fun(obsoleta)
pointer_to_unary_function(obsoleta)
pointer_to_binary_function(obsoleta)
mem_fun(obsoleta)
mem_fun_t
mem_fun1_t
const_mem_fun_t
const_mem_fun1_t
(obsoleta)
(obsoleta)
(obsoleta)
(obsoleta)
mem_fun_ref(obsoleta)
mem_fun_ref_t
mem_fun1_ref_t
const_mem_fun_ref_t
const_mem_fun1_ref_t
(obsoleta)
(obsoleta)
(obsoleta)
(obsoleta)
binder1st
binder2nd
(obsoleta)
(obsoleta)
bind1st
bind2nd
(obsoleta)
(obsoleta)
 
Defined in header <functional>
template< class R, class T >
/*unspecified*/ mem_fn(R T::* pm);
(1) (a partir do 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, mas defeito)
std::mem_fn modelo função gera objetos wrapper para ponteiros para os membros, que pode armazenar, copiar, e chamar um ponteiro para membro. Ambas as referências e ponteiros (incluindo ponteiros inteligentes) para um objeto pode ser usado quando invocando um 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.
As sobrecargas (2), são relatados como defeito.
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.
O resolution, que foi recentemente eleito o "Timidamente Ready" propõe a eliminação de todas as 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.
Isso vai quebrar um código, consulte Exemplo 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.

Índice

[editar] Parâmetros

pm -
ponteiro para membro que será envolvido
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.

[editar] Valor de retorno

std::mem_fn retorna um invólucro chamada de tipo não especificado, que tem os seguintes membros:
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
o tipo de retorno pm se pm é um ponteiro para função de membro, não definido para ponteiro para objeto membro
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*, possivelmente cv qualificado, se pm é um ponteiro para função de membro não recebendo nenhum argumento
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* se pm é um ponteiro para função de membro recebendo um 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 se pm é um ponteiro para função de membro recebendo um argumento do 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 o alvo em um objeto determinado, com parâmetros opcionais
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.

(função pública membro)

[editar] Exceções

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

[editar] Exemplo 1

Use mem_fn para armazenar e executar uma função de membro e um objeto membro:
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.

#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';
}

Output:

Hello, world.
number: 42
data: 7

[editar] Exemplo 2

Passe uma função de membro para std::transform para criar uma seqüência 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.

#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';
}

Output:

The string lengths are 4 2 1 4 7 4

[editar] Exemplo 3

#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
}


[editar] Veja também

(C++11)
envolve objeto que pode ser chamado de qualquer tipo com a assinatura especificada função chamada
Original:
wraps callable object of any type with specified function call signature
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(modelo de classe) [edit]
(C++11)
se liga um ou mais argumentos para um objeto de função
Original:
binds one or more arguments to a function object
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(modelo de função) [edit]