2010-06-05 12 views
17

Me doy cuenta de que esta es una pregunta ridícula por algo que lleva menos de 2 segundos implementar. Pero recuerdo vagamente haber leído que uno fue presentado con el nuevo estándar.¿Existe un objeto de función "no hacer nada" no operativo en C++ (0x)?

Agilicé los encabezados de VC10 y no se me ocurrió nada. ¿Puede usted ayudar? Me está molestando! :)

edición: Pensándolo bien, la nueva funtor Estaba recordando fue probablemente la relación std::default_deleter.

+3

Qué pérdida de puntos airmiles. ¡Imagine los ahorros que podría haber hecho si esta no fuera una pregunta de CW! – wilhelmtell

Respuesta

23

Siempre se puede escribir una lambda no-op: []{}

+0

Me gusta esto, pero no funciona para el número de 'std :: conditional' s que he esparcido. Y un '' std :: function' va a arrojar al operador(). – dean

+1

'[] (...) {}' funcionará para cualquier cantidad de argumentos de entrada. – Mikhail

0

Probablemente estaba pensando en la función identidad (std :: identidad y aparentemente se remueve en el proyecto actual) que no es lo mismo sin embargo.

+0

Sabía de 'identidad' pero lo descarté por ser unario. Recuerdo haber necesitado un default_deleter genérico para algo, hace seis meses ... no puedo recordar para qué. – dean

1

¿Qué tal esto?

// Return a noop function 
template <typename T> 
struct noop 
{ 
    T return_val; 

    noop (T retval = T()) 
     : return_val (retval) 
    { 
    } 

    T 
    operator (...) 
    { 
    return return_val; 
    } 
}; 

template <> 
struct noop<void> 
{ 
    void 
    operator (...) 
    { 
    } 
}; 

Esto debería funcionar para casi cualquier uso.

+0

Tenga en cuenta que esto falla si alguna vez intenta pasar un tipo no copiable trivialmente como un argumento a noop, porque no funcionan con ... – rerx

0

Utilizo esto como un drop-in no operativo para casos donde espero un functor que no devuelva ningún valor.

struct VoidNoOp { 
    void operator()() const { } 
    template<class A> 
    void operator()(A a) const { (void)(a); } 
    template<class A, class B> 
    void operator()(A a, B b) const { (void)(a); (void)(b); } 
    template<class A, class B, class C> 
    void operator()(A a, B b, C c) const { (void)(a); (void)(b); (void)(c); } 
}; 

Aquí es una variación de C++ 11 para un número arbitrario de parámetros:

struct VoidNoOp { 
    void operator()() const { }; 
    template<typename P1, typename... Params> 
    void operator()(P1 p1, Params... parameters) { 
     (void)(p1);    // we do this just to remove warnings -- requires the recursion 
     operator()(parameters...); 
    } 
}; 
Cuestiones relacionadas