En una función de plantilla C++, ¿puedo devolver un tipo de argumento desreferenciado?

Question

Lo que quiero decir es lo siguiente. Quiero una función de plantilla que tome dos iteradores de vector (o dos punteros a una matriz de doble) y devuelve un doble que de alguna manera está relacionado con los iteradores de vector o los punteros de matriz que paso. Sin embargo, quiero que esto funcione para el tipo doble o int, o cualquier tipo aritmético.

creo que no se me permite decir:

template <class T> 
T* func(T Begin, T End) 

T new_variable = Begin + 5; 

return (*new_variable); 
} 

porque el compilador no va a entender lo T * medios. Una solución en la que pensé es tomar lo que estoy tratando de devolver y convertirlo en un tercer argumento:

template <class T> 
void func(T Begin, T End, T* new_variable) 

new_variable = Begin + 5; 

return (*new_variable); 
} 

¿Funcionará? Incluso si es así, ¿hay otra forma de hacer lo que estoy tratando de hacer? (Lo siento si no he sido lo suficientemente claro.)

Answer 1

Si desea devolver un doble (es decir, del tipo que se podrían obtener cuando eliminación de referencias), puede utilizar las características de iterador:

template<typename RandomAccessIterator> 
typename std::iterator_traits<RandomAccessIterator>::value_type 
func(RandomAccessIterator a, RandomAccessIterator b) { 
    typedef typename std::iterator_traits<RandomAccessIterator>::value_type 
     value_type; 

    // use value_type now, when you want to save some temporary 
    // value into a local variable, for instance 
    value_type t = value_type(); 
    for(; a != b; ++a) t += *a; 
    return t; 
} 

Estos trabajo para todos los iteradores, incluidos los punteros:

int main() { 
    int d[3] = { 1, 2, 3 }; 
    assert(func(d, d + 3) == 6); 
} 

Answer 2

Bueno, su código parece contradecir lo que describió en el texto. Si T es el tipo de iterador, el resultado del iterador desreferencia (como dijo en el texto) será no si tiene T * (ya que parece creer en el código). T * es algo completamente opuesto: es algo que obtendría si tomara la dirección de su iterador, sin desreferenciarla.

De hecho, no hay forma de expresar el "tipo desreferenciado" usando las características del lenguaje central C++ (tal vez decltype lo hará en el futuro, como en decltype(*T())). La única forma de describir el resultado de la desreferencia del tipo T es usar una solución basada en una biblioteca: rasgos del iterador, como explicó Johannes en su respuesta.