// BitName is an enum whose values are 0 through 7.
std::string binaryString( "" );
for ( BitName bit = startBit; bit >= stopBit; bit = BitName(bit - 1) )
{
char result( m_binary.at(bit) );
binaryString.insert(0, &result);
}
std::string binaryString( "" );
for ( BitName bit = startBit; bit >= stopBit; bit = BitName(bit - 1) )
{
char result( m_binary.at(bit) );
binaryString.insert(0, &result, 1);
}
string.insert(0, 1, my_char);string.insert(string.begin(), my_char); //my favourite of these//or even: treat the char as a C-string, but just request one character from itstring.insert(0, &my_char, 1); string += my_char;//when donestd::reverse(string.begin(), string.end());Quote:Original post by Belgium
Thanks, again. I always get an education when I post here.
visitor, thanks. I'll look into that. I knew there was a reverse() somewhere but in my annoyance/ignorance at not getting insert() to work I neglected to go find it. It definitely offers some possibilities because just above that snippet of code is another loop that looks very similar except it wouldn't require a reversal of the string because the user entered start and stop in a different order.
Quote:Original post by Zahlman
Um... what exactly is the full set of code supposed to do? I suspect you're over-thinking things. Show the entire function and I'll see what ideas I can give you.
std::string KlOctet::getBinary(const BitName& start, const BitName& stop) const{ // Remember, BitName starts with B7 and descends to B0. However, internally, B7 == 0 // and B0 == 7. This may make some of the following look weird. // Ensure that 'start' is the most-significant-bit and 'stop' is the least-significant-bit. // If not, swap them so this is true. BitName startBit( start ); BitName stopBit( stop ); if ( startBit > stopBit ) { std::swap(startBit, stopBit); } // Extract each bit and add it to binaryString in the order they were extracted. This will // result in the most-significant-bit being the leftmost element in the string and the // least-significant bit being the rightmost element in the string. std::string binaryString( "" ); for ( BitName bit = startBit; bit <= stopBit || bit == startBit; bit = BitName(bit + 1) ) { char result( m_binary.at(bit) ); binaryString += std::string(&result, 1); } return binaryString;}// I prefer 'asBinary' as a name because it implies an alternate representation// for the data, rather than simple access.std::string KlOctet::asBinary(BitName start, BitName stop) const { if (start > stop) { std::swap(start, stop); } std::string binaryString; for (BitName bit = start; bit <= stop || bit == start; ++bit) { binaryString += char(m_binary.at(bit)); } return binaryString;}Quote:Original post by Zahlman
Instead of passing by const-reference and then making your own copies, just pass by value. That way, you make the copies that you need anyway, and you don't have to come up with separate names for the parameters and the copies.
'bit == start' can't ever happen in your for-loop, unless 'BitName()' does some kind of looping logic. I was assuming BitName is just an enumeration, though, such that this is just a cast.
Consider overloading operator++ for BitName. That way you can make it do the looping logic if necessary, too.
Oh, and you can append a single char to a std::string with operator+ and it does what you want; no need to mess around creating a string. (You can append a null-terminated char*, too.) (And what's in m_binary that you have to cast the result to char? If it's a vector of char, then no cast is needed; if it's a vector of bool, then the cast will give you 0 and 1 bytes rather than '0' and '1' symbols.)
