ich suche nach einer möglichkeit (nicht boost ) einen stream zu verarbeiten nach dem prinzip

Stream<VerarbeitungsAlgo> s;
cout << s << "irgendwelche daten";
//oder 
foo << s << bar

wobei cout und "irgendwelchen daten" durch eine beliebiges Objekt ersetzt werden können. zB fstream, char-array, string usw.
Außerdem kann sich die größe des Ausagbestreams verkleinern oder vergrößern.

Ich möchte also in s den Inhalt verändern.

Welchen Ansatz müsste ich dabei verfolgen bzw kleine Beispiel sources wären sehr hilfreich.

Andererseits finde ich den Vorteil ggü. der "klassischen Form" nicht wirklich überwältigend:

VerarbeitungsAlgo s; // oder einfach eine geeignete Funktion s
cout << s("irgendwelche daten");
//oder
foo << s(bar);

Man muss nur darauf achten, dass für das Ergebnis von s (sei es nun eine Funktion oder ein Funktor) ein geeigneter operator<<() definiert ist ... aber das ist auch schnell selbst gemacht.

Die Idee eines "generellen Algorithmus'" halte ich sowieso für nicht allzu hilfreich. Wie soll ein Algorithmus aussehen, der TCP-Connections, Autos und Kundenkontakte gleichartig verarbeiten kann ?

Gruß,

Simon2.

Es geht mir hierbei primär um die Ansätze wie man mit meiner Methode lösen könnte.

Encryptor<AlgoType> encryptor;
std::string toEncrypt("Hello");
std::string encrypted;

encryptor(toEncrypt.begin(), toEncrypt.end(), std::back_inserter(encrypted));

std::cout << encrypted << std::endl;

// Und die Klasse Encryptor irgendwie so:
template<typename AlgoTypeT>
class Encryptor
{
public:
  template<typename InIterT, typename OutIterT>
  void operator ()(InIterT first, InIterT last, OutIterT out)
  {
    AlgoTypeT algo;

    for(; first != last; ++first, ++out)
    { *out = algo.encrypt(*first); }
  }
};

Oder sowas ähnliches ...?

Grüssli

#pragma once
#include <iostream>
#include <string>
#include "tea.h"
#include "rc4.h"

namespace crypt
{
	template<class algo>
	class CipherBuffer: public algo
	{
		private:
			algo theAlgo;

		public:
			CipherBuffer(const algo &theAlgo)	{};
			~CipherBuffer()						{};
	};

	///instanz vom user
	template<class algo>
	class CipherStream: public CipherBuffer<algo>
	{
		public:
			CipherStream(const algo &theAlgo = algo());
			~CipherStream();

	};

	template<class algo>
	CipherStream<algo>::CipherStream(const algo &theAlgo): CipherBuffer<algo>(theAlgo)
	{

	}

	template<class algo>
	CipherStream<algo>::~CipherStream()
	{

	}
}

#pragma once
#include <iostream>
#include <string>

namespace crypt
{
	class RC4
	{
		private:

		public:
			RC4()	{};
			~RC4()	{};

			void operator<< (std::string &s)
			{
				std::cout << s << std::endl;
			};
	};
}

#include <iostream>
#include <string>

#include "cipher.h"

#include <stdio.h>

using namespace std;
using namespace crypt;

int main(int argc, char **argv)
{
	string s = "Test";
	CipherStream<RC4> rc4;

	rc4 << s;

	system("pause");
	return 0;
}