Deducción de tipo de argumento, referencias y valores

Question

Considere la situación en la que una plantilla de función necesita reenviar un argumento manteniendo su valor en caso de que sea un valor no const, pero es agnóstico de lo que realmente es el argumento, como en :

template <typename T> 
void target(T&) { 
    cout << "non-const lvalue"; 
} 

template <typename T> 
void target(const T&) { 
    cout << "const lvalue or rvalue"; 
} 


template <typename T> 
void forward(T& x) { 
    target(x); 
} 

Cuando x es un valor de lado derecho, en lugar de T deduciéndose a un tipo constante, se da un error:

int x = 0; 
const int y = 0; 

forward(x); // T = int 
forward(y); // T = const int 
forward(0); // Hopefully, T = const int, but actually an error 
forward<const int>(0); // Works, T = const int 

parece que para forward para manejar rvalues ​​(sin callin g para argumentos de plantilla explícitos) debe haber una sobrecarga forward(const T&), aunque su cuerpo sería un duplicado exacto.

¿Hay alguna forma de evitar esta duplicación?

Answer 1

Este es un problema conocido y el propósito de las referencias de rvalue en C++ 0x. El problema no tiene solución genérica en C++ 03.

Hay alguna razón histórica arcaica por la que esto ocurre que es muy inútil. Recuerdo haber preguntado una vez y la respuesta me deprimió mucho.

Answer 2

When x is an rvalue

Pero x nunca es un valor de lado derecho, porque los nombres son lvalues.

Is there any way to avoid this duplication?

Hay una forma en C++ 0x:

#include <utility> 

template <typename T> 
void forward(T&& x) // note the two ampersands 
{ 
    target(std::forward<T>(x)); 
} 

Gracias al hacer referencia a las reglas el colapso, la expresión std::forward<T>(x) es de la misma categoría de valor como argumento a su propia función de avance.

Answer 3

Suponiendo que hay k argumentos, como yo lo entiendo, la única "solución" en C++ 03 es escribir manualmente funciones de reenvío de 2^k tomando todas las combinaciones posibles de los parámetros & y const&. Por ejemplo, imagine que target() en realidad tomó 2 parámetros. A continuación, tendría:

template <typename T> 
void forward2(T& x, T& y) { 
    target(x, y); 
} 

template <typename T> 
void forward2(T& x, T const& y) { 
    target(x, y); 
} 

template <typename T> 
void forward2(T const& x, T& y) { 
    target(x, y); 
} 

template <typename T> 
void forward2(T const& x, T const& y) { 
    target(x, y); 
} 

Obviamente, esto se pone muy difícil de manejar para k grande, por lo tanto, las referencias rvalue en C++ 0x como han mencionado otras respuestas.

Answer 4

En general, este desagradable problema con las plantillas debe requerir duplicación porque la semántica donde una variable es const o no, o una referencia o no, son bastante distintas.

La solución C++ 11 para esto es "decltype" pero es una mala idea porque todo lo que hace es compuesto y ya está roto sistema de tipo.

No importa lo que diga la Norma o el Comité, "const int" no es y nunca será un tipo. Tampoco será "int &" alguna vez un tipo. Por lo tanto, nunca se debe permitir que un parámetro de tipo en una plantilla se vincule con tales no-tipos, y afortunadamente para la deducción este es el caso. Lamentablemente, todavía puedes forzar explícitamente esta sustitución sin principios.

Hay algunas reglas idiotas que tratan de "arreglar" este problema, tales como "const int const" reducir a "const int", ni siquiera estoy seguro de lo que sucede si usted consigue "Int & &": recordar incluso el estándar no cuenta "int &" como un tipo, hay un tipo "int valor-I", pero que es distinta:

int x;  // type is lvalue int 
int &y = x; // type is lvalue int 

la solución adecuada a este problema es muy simple: todo es un objeto mutable . Deseche "const" (no es tan útil) y elimine las referencias, lvalues ​​y rvalues. Está bastante claro que todos los tipos de clases son direccionables, rvalue o no (el puntero "this" es la dirección). Hubo un intento vano por parte del comité de prohibir asignar y abordar valores. El caso de direccionamiento funciona, pero se escapa fácilmente con un elenco trivial. El caso de asignación no funciona en absoluto (porque la asignación es una función miembro y los valores r no son const, siempre se puede asignar a un tipo de clase rvalue).

De todos modos la plantilla meta-programación multitud tiene "decltype" y con eso usted puede encontrar la codificación de una declaración incluyendo cualquier "const" y "&" bits y luego puede descomponer esa codificación utilizando varios operadores de biblioteca. Esto no pudo hacerse antes porque esa información no es realmente información de tipo ("ref" es en realidad información de asignación de almacenamiento).