also, ich hatte ja schon einmal ein thema offen, wo es darum ging, dezimalzahlen in binäre umzuwandeln..

hm ich mach jetzt einfach mal nochmal das ganze, da dort keiner mehr reinschreibt.

also, ein vorschlag war dieser hier:

template <unsigned int NrOfBits>
string DezToBin(int Wert)
{
    bitset<NrOfBits> AlsBits(Wert);
    return AlsBits.to_string();
}

mein problem ist:

82 ... expected primary-expression before "template"

das und außerdem:

134 ... NrOfBits' undeclared (first use this function) 134 ... template argument 1 is invalid 134 ... invalid type in declaration before '(' token 135 ...to_string' has not been declared
135 ... request for member of non-aggregate type before '(' token

diese ganzen ...

also: das rundherum zu zeile 82:

int nr_of_zs;
    string bin;
    for(int i = 0; i < length(src); i++) {
            nr_of_zs = wandle_in_nummern(src[i]);
            cout<<nr_of_zs<<endl;
            template <unsigned int NrOfBits> // zeile 82
            bin = DezToBin ( nr_of_zs);
            cout<<bin<<endl;
            }

und die funktion mit den zeilen 134 und so steht ja oben schon ( als vorschlag nur ohne das template eben)

was ist hier falsch?

template <unsigned int NrOfBits> // zeile 82
            bin = DezToBin ( nr_of_zs);

du musst angeben, wieviele bits du willst:

bin = DezToBin<10>(nr_of_zs);

und diese 'zeile 82' einfach weglassen

int zahl
while (zahl > 0){
    cout << zahl%2;
    zahl /= 2;
}

Falschrum.

Krux schrieb:

int zahl
while (zahl > 0){
    cout << zahl%2;
    zahl /= 2;
}

Falschrum.

ja ist mir auch aufgefallen, aber das kann der selbst umdrehen hab ich mir da gedacht, anstatt nochmal alles selbst zu bearbeiten.

std::string to_bin_str(unsigned int n)
{
    return n ? to_bin_str(n / 2) + (n % 2 ? '1' : '0') : "";
}

std::string to_binary( unsigned int n )
{
	return n ? to_binary( n >> 1 ) + char( '0' + ( n & 1 ) ) : "";
}

void print_bits (unsigned v)
{
    unsigned z = v>>1; if(z) print_bits (z); putchar ('0' + v-(z<<1));
}

void to_binary( unsigned int n )
{
	if ( n ) to_binary( n >> 1 ), putchar( '0' + ( n & 1 ) );
}

Der rekursive Konrad wieder

Ich mag Rekursion. Auch wenn ich sie in diesem Fall mangels Effizienz nie einsetzen würde.

Warst du eigentlich der, der mal nen Link zu einer Algo-Sammlung-Seite gepostet hatte und meinte man solle sich da paar aussuchen und die zu implementieren üben, wenn ja, kannst du nochmal den Link posten ?

Kloar: http://www.nist.gov/dads/

David_pb schrieb:

Da, genauso Sinnfrei aber mit cast und dafür etwas schneller!

std::string to_binary( unsigned int n )
{
	return n ? to_binary( n >> 1 ) + char( '0' + ( n & 1 ) ) : "";
}

Ich bin mir nicht sicher, ob das schneller ist. Ein guter Compiler macht aus 'n / 2' doch eh eine Shift-Operation. Ob die char-Addition schneller ist als eine Verschachtelung, müsste man mal testen.

Aber ohne std::string ist die Differenz bis zu 99%.

damit haben wir, mit sinnlosen codes, nachgewiesen, dass std::string mit vorsicht zu geniessen ist

David_pb schrieb:

Aber ohne std::string ist die Differenz bis zu 99%.

damit haben wir, mit sinnlosen codes, nachgewiesen, dass std::string mit vorsicht zu geniessen ist

Nöö, wir haben nachgewiesen, dass eine Konkatenation ohne passende Speicherallokationsstrategie ineffizienter als das Schreiben in einen gepufferten Zeichenstrom ist. Und das wussten wir ja auch davor schon.

wieso nennt ihr eure versionen sinnlos ?

Meine, weil sie (sinnlos) ineffizient ist. Die 'putchar'-Variante, weil sie eine verkorkste Schnittstelle hat (ich will keine Ausgabe. Ich will eine *Rück*gabe).

für manche aufgabenstellungen macht das doch sinn, sich die binärdarstellung anzusehen ?

Ja, dann kann man doch einfach die std::bitset-Klasse verwenden (oder sich eine sinnvolle Implementierung schreiben).

Kloar: http://www.nist.gov/dads/

Danke.