ich versuche gerade einen stream manipulator zu schreiben, der eine zahl (dezimal) als dualzahl ausgibt. er soll mittels dem &-operator überprüfen ob ein bit gesetzt ist oder nicht. bei manipulatoren ohne parameter schien mir das recht einfach, aber ich hab da mal was gelesen, dass man, wenn man sie mit parametern verwenden will, einen umweg über eine hilfsklasse gehen muss und irgendwelche funktionen casten muss etc. Das hab ich leider nicht verstanden und wollte fragen ob mir das hier im Forum jemand nochmal näherbringen könnte. Der Manipulator sollte diesselbe ausgabe wie diese funktion haben, nur sollte er die Ziffern eben direkt auf den ausgabestream schieben

const int BITS_PER_BYTE = 8;

template<class T>
std::string dual(T n, bool complete=true)//print in Dual
{
	std::stringstream s;
	size_t size = sizeof(n) * BITS_PER_BYTE;

	//nur datentypen kleiner oder gleich gross int zulassen
	if(size>32)
		return "";

	//Wenn erst ab dem ersten gesetzten Bit ausgegeben werden soll,
	//dann dieses erst suchen.
	while(!complete && !(n & 1<< size-1))
		--size;

	for(int i = size -1; i>=0; --i)
		//in einen boolschen ausdruck konvertieren und dann in den stream schieben
		s<<((n & 1<<i) != 0);

	return s.str();
}

Vielen Dank schonmal im Voraus

cout << dual << meinZahl;

oder sowas:

cout << dual(meinZahl); // <<- das hast du ja schon

#include <iostream>
#include <bitset>

template< typename _CharT, typename _Traits >
class my_ostream : private std::basic_ostream< _CharT, _Traits >
{
public:
	explicit my_ostream( std::basic_streambuf<_CharT, _Traits>* __sb )
		: std::basic_ostream< _CharT, _Traits >( __sb )
		, flags( 0 )
	{}

	std::basic_ostream< _CharT, _Traits >& my_ostream< _CharT, _Traits >::operator<<( long __n )
	{
		if ( flags ) // flags prüfen
		{
			return ( ( *this ) << std::bitset< 32 >( __n ) );
		}
		else
			return std::basic_ostream< _CharT, _Traits >::operator<<( __n );
	}

	void setflags( unsigned long v )
	{
		flags |= v;
	}

private:
	unsigned long flags;
};

struct dual_t
{};

template< typename _CharT, typename _Traits >
my_ostream< _CharT, _Traits>& operator<<( my_ostream< _CharT, _Traits>& out, const dual_t& manipulator )
{
	out.setflags( 1 );
	return out;
}

static const dual_t dual = dual_t();

int main()
{
	my_ostream< char, std::char_traits< char > > stream( std::cout.rdbuf() );
	stream << dual << 234;
}

So ähnlich sollt das funktionieren. Allerdings nicht mit dem Standard ostream da dieser keinen Flags für das duale Zahlensystem hat. Mir würd zumindest spontan keine Lösung einfallen das auf dem herkömmlichen Weg zu lösen.

@ David_pb: Vielen dank für den Code. Ich werd ihn mal durchgehen, da ichs beim ersten überfligen noch nicht ganz kapiert habe. ich schau auch mal, ob ich die oben erwähnte beschreibung nochmal wiederfinde, denn ich glaub' da gings mit der klasse ostream, bin mir aber nicht mehr sicher.

struct manip
{
    std::ostream& (*f)(std::ostream&, int, bool);
    int n;
    bool complete;

    manip(std::ostream& (*f_)(std::ostream&, int, bool), int n_, bool complete_)
        : f(f_), n(n_), complete(complete_)
    { }
};

const int BITS_PER_BYTE = 8;
std::ostream& dual_(std::ostream& os, int n, bool complete)//print in dual
{ 
    size_t size = sizeof(n) * BITS_PER_BYTE; 

    //nur datentypen kleiner oder gleich gross int zulassen 
    if(size>32) 
        return os;

    //Wenn erst ab dem ersten gesetzten Bit ausgegeben werden soll, 
    //dann dieses erst suchen. 
    while(!complete && !(n & 1<< size-1)) 
        --size; 

    for(int i = size -1; i>=0; --i) 
        //in einen boolschen ausdruck konvertieren und dann in den stream schieben 
        os<<((n & 1<<i) != 0); 

    return os; 
}

manip dual(int n, bool complete=true)
{
    return manip( dual_, n, complete );
}

std::ostream& operator<<(std::ostream& os, manip m)
{
    return m.f( os, m.n, m.complete );
}

int main()
{
    std::cout << dual(255,true) << std::endl;
}

Erklärung:
Die neue Funktion dual setzt du wie einen Manipulator ein. Sie erzeugt eine Variable vom Typ manip , die drei Member hat:

• einen Funktionspointer f , der auf eine Funktion zeigt, die einen Stream manipuliert; hier zeigt er also auf dual_
• ein Integer n ; er dient zur Speicherung des ersten Arguments von dual
• ein Bool complete ; dient ebenfalls zur Speicherung

Diese manip -Variable wird nun mit dem operator<< ausgegeben. In dieser Funktion wird die Funktion, auf die der Funktionszeiger in m zeigt (also hier dual_ ), mit den entsprechenden Argumenten aufgerufen.

dual_ wurde nur so verändert, dass sie in den übergebenen ostream schreibt, statt in einen stringstream.

#include <iostream>
#include <bitset>
#include <string>

std::string dual( int i )
{
	return std::bitset< 32 >( i ).template to_string< char, std::char_traits< char >, std::allocator< char > >();
}

int main()
{
	std::cout << dual( 1234 ) << std::endl;
}

@ david_pb: ja sieht mir einfacher aus als mein vorschlag, aber leider gibt die funktion nur n string zurück.

Wenn dus so lösen willst brauchst du dir nich so einen Umstand machen.

Der "Umstand" ja nur deswegen, damit er direkt in einen Stream schreiben kann. Aber hast schon recht, wenn man ein Manipulator mit Argumenten braucht, dann tuts ein std::string dual(...) am besten und einfachsten.

David_pb schrieb:

Wenn dus so lösen willst brauchst du dir nich so einen Umstand machen.

Der "Umstand" ja nur deswegen, damit er direkt in einen Stream schreiben kann. Aber hast schon recht, wenn man ein Manipulator mit Argumenten braucht, dann tuts ein std::string dual(...) am besten und einfachsten.

NEIN, das ist K-E-I-N manipulator!
das ist deshalb wichtig, da daraus später noch sowas wie std::hex wird und zeig mir mal wie du cout mit einem string verändern willst.

NEIN, das ist K-E-I-N manipulator!

Das ist mir schon klar, lies meinen Satz nochmal und verstehe ihn anders

rudi++ schrieb:

zeig mir mal wie du cout mit einem string verändern willst.

Was meinst du damit ?

das ist deshalb wichtig, da daraus später noch sowas wie std::hex wird und zeig mir mal wie du cout mit einem string verändern willst.

Was genau meinst du damit? Ich seh da kein Problem.

std::cout << std::hex << dual(...);

std::cout<<dual(123456)<<654321<<std::endl;

(dual gibt hiern nen String zurück.)
beim ersten werden alle zahlen, die man in den stream schiebt in hexadezimaler schreibweise ausgegeben, beim zweiten wird nur die ausgabe der ersten zahl verändert. ich wollt deshalb sowas wie std::hex basteln, bei dem dann auch alle nachfolgenden zahlen in binärform ausgegeben werden.

std::cout<<dual<<0xff<<std::endl<<0x0f<<std::endl;

ausgabe:

11111111
00001111

grüße