Eigene Manipulatoren beim operator% in eigener Buffer-Klasse (wie bei streams)

Hallo,

ich habe einen bestehenden Code übernommen. Dort gibt es eine Bufferklasse.Bei dieser Klasse wurde der %-operator überladen, um verschiedene Datentypen in den Buffer einzufügen. Dies funktioniert auch.

Der folgende Code zeigt eine auf das Grundsätzliche reduzierte Klasse.

#include <vector>

using namespace std;

class buffer 
{
    vector<unsigned char> m_buf;
    int m_pos;
    int m_key;

public:
    buffer() : m_key(0), m_pos(0) {}
    virtual ~buffer() {}

    void key(int keynr) {m_key = keynr; m_pos = 0;}    
    void reset() {m_pos = 0;}

    template<typename T>
    buffer& operator%(T const& value)
    {
        if (m_pos + sizeof T > m_buf.size())
            m_buf.resize(m_pos + sizeof T);
        memcpy(m_buf.data() + m_pos, &value, sizeof T);
        m_pos += sizeof T;
        return *this;
    }

    template<>
    buffer& operator%<std::string>(const std::string& s)
    {
        if (m_pos + s.length() > m_buf.size())
            m_buf.resize(m_pos + s.length());
        memcpy(m_buf.data() + m_pos, s.data(), s.length());
        m_pos += static_cast<int>(s.length());
        return *this;
    }
};

// Dies sollte ein Manipulator ohne Parameter sein
buffer& reset(buffer& b)
{
    b.reset();
    return b;
}

// Dies sollte ein Manipulator mit 1 Parameter sein
buffer& key(buffer& b, int keynr)
{
    b.key(keynr);
    return b;
}

int main()
{
    buffer b;

    // b % key(1) % string("hallo") % reset() % int(2);
    // dies funktioniert leider nicht

	return 0;
}

Mein Ziel ist es jetzt diese Klasse um Manipulatoren zu erweitern. Mein Versuch der auf Anleitungen zu Streams beruht funktioniert nicht. Ich habe Manipulatoren ohne Parameter (siehe reset) und Manipulatoren mit 1 Parameter (siehe key).

Kann man dies mit C++ (Visual Studio 2010) lösen

Danke im Voraus

Th69

Ähnlich wie die Stream-Klassen eigene Manipulatorklassen (imanip, omanip, smanip) benutzen (s. Custom Manipulators for User-Defined Objects), mußt du dann eine eigene Buffer-Manipulator-Klasse (buffer_manip) erzeugen und verwenden:

buffer_manip key(int keynr)
{
    return buffer_manip(&key, keynr);
}

Und deine Buffer-Klasse müßte dann den operator% noch für den Parameter buffer_manip spezialisieren:

template<>
buffer& operator%<buffer_manip>(const buffer_manip &x)

Für die Implementierung von buffer_manip schau am besten in die o.g. Templates imanip<T> etc.

Danke für die Hinweise

für einen Manipulator ohne Parameter habe ich inzwischen eine einfache Lösung gefunden.
Ich erweitere die Klasse um folgende Memberfunktion:

buffer& operator%(buffer& (*fp)(buffer&))
    {
        return fp(*this);
    }

Dieser Ansatz funktioniert nicht, wenn der manipulator Parameter hat.

Habe jetzt alles implementiert

Im "Der C++-Programmierer" von Ulrich Breymnann wird es im Kapitel 9 recht gut beschrieben.

Dank an Th69 für die Hinweise

Th69

Bitte sehr