ragmento de código de lexical_cast:

class lexical_castable {
public:
  lexical_castable() {};
  lexical_castable(const std::string s) : s_(s) {};

  friend std::ostream operator<<
    (std::ostream& o, const lexical_castable& le);
  friend std::istream operator>>
    (std::istream& i, lexical_castable& le);

private:
  virtual void print_(std::ostream& o) const {
    o << s_ <<"\n";
  }

  virtual void read_(std::istream& i) const {
    i >> s_;
  }

  std::string s_;
};

std::ostream operator<<(std::ostream& o,
  const lexical_castable& le) {
  le.print_(o);
  return o;
}

std::istream operator>>(std::istream& i, lexical_castable& le) {
  le.read_(i);
  return i;
}

Residencia endocument,

template<typename Target, typename Source>
  Target lexical_cast(const Source& arg);

1> Devuelve el resultado de la transmisión de argumentos en una secuencia de biblioteca estándar basada en cadenas y luego como un objeto de destino.

2> La fuente es OutputStreamable

3> El objetivo es InputStreamable

Pregunta > Para el tipo definido por el usuario (UDT), si OutputStreamable o InputStreamable siempre tienen que tratar constd::string? Por ejemplo, dada una clase que contiene un entero simple como variable miembro, cuando definimos laoperator<< yoperator>>, ¿cómo es el código de implementación? ¿Tengo que convertir el entero como una cadena? Según mi comprensión, parece que UDT siempre tiene que lidiar constd::string para trabajar conboost::lexical_cast yboost::lexcial_cast necesita el intermediostd::string para realizar los trabajos de conversión reales.

Pregunta > ¿Por qué el valor de retorno deoperator<< ooperator>> en el código anterior no hace referencia astd::ostream& ostd::istream& respectivamente?