Dans une fonction de modèle C++, puis-je retourner un type d'argument déréférencé?

Question

Ce que je veux dire est le suivant. Je veux une fonction template qui prend deux itérateurs vectoriels (ou deux pointeurs sur array of double) et renvoie un double qui est en quelque sorte lié aux itérateurs vectoriels ou aux pointeurs de tableau que je passe. Cependant, je veux que cela fonctionne pour double ou int, ou n'importe quel type arithmétique.

Je pense que je ne suis pas autorisé à dire:

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

T new_variable = Begin + 5; 

return (*new_variable); 
} 

parce que le compilateur ne comprendront pas ce T * signifie. Une solution que je pensais est de prendre ce que je suis en train de revenir et en faire un troisième argument:

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

new_variable = Begin + 5; 

return (*new_variable); 
} 

Est-ce que ce travail? Même si c'est le cas, y a-t-il une autre façon de faire ce que j'essaie de faire? (Désolé si je ne l'ai pas été assez clair.)

Answer 1

Si vous voulez retourner un double (à savoir le type que vous obtenez lorsque déréférencement), vous pouvez utiliser les traits de iterator:

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

Ces travailler pour tous les itérateurs, y compris les pointeurs:

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

Answer 2

Eh bien, votre code semble contredire ce que vous avez décrit dans le texte. Si T est le type d'itérateur, alors le résultat de l'itérateur déréférencer (comme vous l'avez dit dans le texte) pas avoir le type T * (comme vous semblez croire dans le code). T * est une chose complètement opposée: c'est quelque chose que vous obtiendriez si vous preniez l'adresse de votre itérateur, pas déréférencé.

En fait, il n'y a aucun moyen d'exprimer le "type déréférencé" en utilisant les fonctionnalités du langage C++ (peut-être que decltype le fera dans le futur, comme dans decltype(*T())). La seule façon de décrire le résultat du déréférencement de type T consiste à utiliser une solution basée sur une bibliothèque: les caractères itératifs, comme Johannes l'a expliqué dans sa réponse.