Ich habe einen std::string, den ich gerne mit einem std::istringstream parsen würde.

Die normale Technik wäre es wohl, den Stream einfach über den Konstruktor zu initialisieren, hierbei fällt aber der Overhead von Speicherallozierung und das Kopieren des kompletten Strings an.

Wäre es nicht möglich, den std::string direkt in den Streambuffer zu injecten, so dass dieser direkt genutzt wird? Oder wäre es alternativ möglich, den Umweg über den string komplett wegzulassen und direkt in den Buffer des stringstreams zu schreiben?

Danke schon mal.
Grüße,
Ethon

hast du schon mal ein Beispiel kompeliert und angeschaut was der Compiler tatsächlich macht?
Und wenn es dir nicht gefällt, dann aktiviere doch mal C++0x.

#include <streambuf>
#include <istream>    
#include <string>

#include <iostream>

class string_buf : public std::streambuf
{
public:
  string_buf(std::string &str):
    str(str)
  , index(0)
  { }

protected:
  virtual int_type underflow() 
  {
    if (index < str.length())
      return (traits_type::to_int_type(str[index]));  
    else
      return traits_type::eof();
  }
  virtual int_type uflow()      
  {
    if (index < str.length())
      return (traits_type::to_int_type(str[index++]));  
    else
      return traits_type::eof();
  }
private:
  string_buf( const string_buf& );
  string_buf& operator=( const string_buf& );

  const std::string &str;
  std::size_t index;
};

int main()
{
   std::string content = "Hallo Welt!\n99 Flaschen hängen an der Wand.\nDies ist ein toller Taschenrechner\nUnd 'tschüss.";
   string_buf foo(content);
   std::istream ifs(&foo);

  int i=0;
  std::string out;
  while(getline(ifs,out)) std::cout << "Zeile " << i++ << ": " << out <<'\n';
}

Ich habe mir den Buffer jetzt so gebaut:

template<typename Char>
    class ReferencingStringBuffer : public std::streambuf
    {
    private:
      Char const* m_string;

    public:
      ReferencingStringBuffer(Char const* string)
        : m_string(string)
      { }

    protected:
      virtual int_type underflow()
      {
        if(*m_string)
          return traits_type::to_int_type(*m_string);
        else
          return traits_type::eof();
      }

      virtual int_type uflow()
      {
        if(*m_string)
          return traits_type::to_int_type(*m_string++);
        else
          return traits_type::eof();
      } 
    };

Wieso verbietest du das Kopieren deines Streambuffers?
Gibt es noch weitere Gründe gegen das Kopieren außer der Tatsache, dass sich mehrere Streams einen Buffer teilen?

Wieso verbietest du das Kopieren deines Streambuffers?

Dafür gibt's hier keinen Grund mehr. Ich habe mit dem Code meines Standardbuffers angefangen und den an das Problem angepasst. Bei dem macht das auch Sinn, dass er nicht kopierbar ist. Und hier habe ich einfach vergessen, das rauszumachen. Ich sehe keinen Grund, warum dieser Buffer nicht kopiert werden sollte.