void* of a bool[] conversion to std::string

Question

I need to save some data and the only viable option is a std::string; so I get a bool array passed as a void*. Now I need to save it in a way that I can convert it into a std::string and be able read a void* to a bool[] from that exact string. Sadly I got lost in conversion.

f(const void* data, int length){

   bool** boolPointer = (bool**)(data);
   bool boolArray[length];

   for (int i=0; i<=length; i++){
       boolArray[i] = p[sizeof(bool)*i];
   }

   std::string s = (std::string&)boolArray;
}

I'm pretty sure the last line is no viable conversion, but that was my attempt.

Why do you need to convert it to a std::string? What kind of format should that std::string have? One does not simply convert something to a string. — R. Martinho Fernandes, Jan 24 '13 at 12:57
@Ashot if anything, he should do `std::copy(boolPointer, boolPointer+length, &boolArray[0])`. But I don't see why that would be needed at all. — R. Martinho Fernandes, Jan 24 '13 at 13:00
@R. Martinho Fernandes sadly it is very late in the project and std::string is the interface to the data saving mechanism. — dos, Jan 24 '13 at 13:00
The important part is the format that the string should have. You don't just "convert to a string". You "build a string with a certain format". — R. Martinho Fernandes, Jan 24 '13 at 13:02
@R.MartinhoFernandes :) `std::string serial( (char *) boolArray, (char *) ( boolArray + length ) );` — Potatoswatter, Jan 24 '13 at 13:07

Chubsdad · Accepted Answer · 2013-01-24T13:20:11.817

3

Does this work for you?

char f(bool b)
{
    return b ? '1' : '0';
}

int main()
{
    // let's just consider whatever is there in this uninitialized array
    bool buf[100];

    std::string s;

    // transform and copy (convert true to '1' and false to '0')
    std::transform(&buf[0], &buf[99], std::back_inserter(s), f);

    std::cout << s << std::endl;
}

If you are on C++11, you can use the following code snippet

int main()
{
    bool buf[100];

    std::string s;

    std::transform(&buf[0], &buf[99], std::back_inserter(s), [](bool const &b){ return b ? '1' : '0'; });
    std::cout << s << std::endl;
}

edited Jan 24 '13 at 13:20

answered Jan 24 '13 at 13:09

Chubsdad

24,777
4
73
129

`[](bool b) { return b ? '1' : '0'; }` ? – Bartek Banachewicz Jan 24 '13 at 13:13
@Bartek Banachewicz: Initially wrote that and removed as I did not notice the C++11 tag :). – Chubsdad Jan 24 '13 at 13:15
please take a look at http://meta.stackexchange.com/a/133649/186268 – Bartek Banachewicz Jan 24 '13 at 13:20
@Bartek Banachewicz: Ok, thanks. I stand corrected if that's what is the guidline. – Chubsdad Jan 24 '13 at 13:22
thank you very much. not C++11 I'm afraid; I'll use the C++03 tag next time then? – dos Jan 24 '13 at 14:03
1

why not &buf[100] ? ..one pass the end ?? – qPCR4vir Jan 24 '13 at 14:48
@qPCR4vir Or even `(buf, buf+100, ...)` – Peter Wood Jan 24 '13 at 14:57

score 0 · Answer 2 · edited Feb 08 '13 at 16:01

0

Well, I guess you could just open up your C++ book...

std::string f(std::vector<unsigned char> const& v)
{
    std::string temp;

    for (auto c : v) {
        for (unsigned i = 0; i < 8; ++i) {
            temp += (c & (1 << i)) ? '1' : '0';
        }
    }

    return temp;
}

That could probably be done even easier with something like std::copy or some other cryptic back_inserter thingy, but I wanted to keep it simple. Another option would be to use std::bitset or your own encapsulation, to get rid of ugly bit operations.

If you're forced by the devil to pass the data by void*, just convert it to vector:

unsigned char* begin = static_cast<unsigned char*>(data);
vector<unsigned char> v (begin, begin + length);

Please also note that if it's for serialization purposes, that representation will be hardly readable both by computer and a human. If it's meant to be read by computer, save it as binary without conversions. If it's meant to be read by humans, save it as hex characters (splitting every byte in half).

edited Feb 08 '13 at 16:01

Lightness Races in Orbit

378,754
76
643
1,055

answered Jan 24 '13 at 13:06

Bartek Banachewicz

38,596
7
91
135

1

I am not sure if he is on C++11. at least not tagged so – Chubsdad Jan 24 '13 at 13:11
2

@Chubsdad I am using the **current** standard, which happens to be C++11. If he needs to use *older* standard, he should tag it appropriately. – Bartek Banachewicz Jan 24 '13 at 13:12
If I have got it right, c++11 is the tag to be used for questions pertaining to new C++ standard – Chubsdad Jan 24 '13 at 13:13
@Chubsdad that would make an awful load of questions tagged inappropriately. Anyway, it's fairly easy to convert the example to C++03. – Bartek Banachewicz Jan 24 '13 at 13:15
2

@Chubsdad no, the C++ tag is for C++, the C++XX tags are for question that are specific that XX version of C++. It's that simple – thecoshman Jan 24 '13 at 13:20
Seems strange that you qualified `vector` but not `string`. Let's promote some consistency! – Lightness Races in Orbit Feb 08 '13 at 16:00

score 0 · Answer 3 · answered Jan 24 '13 at 13:20

You can overload the output operator to convert the booleans to whatever you want:

ostream& operator<<(const ostream& os, const bool& value) {
    return os << (value ? "1" : "0");
}

Then copy the array to a stringstream:

int main() {
    // ...
    ostringstream oss;
    copy(data, data+size, ostream_iterator<bool>(oss));

    oss.str(); // this is the string you're looking for
    // ...
}

void* of a bool[] conversion to std::string

3 Answers3