Comment lire une valeur avec l'opérateur > > mais pas de constructeur par défaut à la valeur?

Question

template <class T>
T Read () {
  T t;
  cin >> t;
  if (cin.fail()) {
    // ...
  }
  return t;
}

Ce code générique lit la valeur du type T avec un traitement d’erreur supplémentaire. Cela dépend de l'opérateur > > cela peut analyser T, et de cette façon, il est extensible à de nouveaux types.

Ce que je n’ai pas compris, c’est qu’il faut que T ait un constructeur par défaut. Maintenant, j'ai abordé ce problème.

Quelles sont mes options?

Quelle est la bonne façon de le faire?

Answer 1

La diffusion à partir d’un flux d’entrée suppose toujours qu’un objet entièrement construit soit écrit. Vous ne pouvez pas vous passer de la construction d'un objet, vous pouvez simplement autoriser différentes façons de le faire.

Une façon de faire cela pourrait être les traits. Les traits standard feraient ce que vous faites:

template< typename T >
struct istream_traits
{
  inline static T read(std::istream& is)
  {
    T obj;
    is >> obj;
  }
}

template< typename T >
inline T read(std::istream& is)
{
  is >> std::ws;
  T obj = istream_traits<T>::read(is);
  is >> std::ws;
  if(!is.eof()) throw "dammit!";
  return obj; 
}

Si vous avez un type X qui ne peut pas être construit par défaut, mais peut être construit à partir d'un istream, la spécialisation suivante ferait l'affaire:

template<>
struct istream_traits<X>
{
  inline static X read(std::istream& is)
  {
    return X(is);
  }
}