«

std::string s = "easy";

std::string unicode_string;

std::string::const_iterator it,

for(it = s.begin(); it != s.end(); ++it)
{
unicode_string.push_back(*it);
unicode_string.push_back('\0');
}

The above for loop would make unicode_string look like this:

"e null a null s null y null"

Is there a faster way to do this... in place maybe?

Thanks for any tips,

Brad

Brad <>, on 05/09/2010 09:54:28, wrote:

> std::string s = "easy";
>
> std::string unicode_string;
>
> std::string::const_iterator it,
>
> for(it = s.begin(); it != s.end(); ++it)
> {
> unicode_string.push_back(*it);
> unicode_string.push_back('\0');
> }
>
> The above for loop would make unicode_string look like this:
>
> "e null a null s null y null"

Nay, it will make it look like "e\0a\0s\0y\0"... by the way, why do you
need to do such a thing?

> Is there a faster way to do this... in place maybe?

Faster, I don't know (measure it), in place, yes: use the
std::string::insert() method.

--
FSC - http://userscripts.org/scripts/show/59948
http://fscode.altervista.org - http://sardinias.com

* Brad, on 05.09.2010 18:54:
> std::string s = "easy";
>
> std::string unicode_string;
>
> std::string::const_iterator it,
>
> for(it = s.begin(); it != s.end(); ++it)
> {
> unicode_string.push_back(*it);
> unicode_string.push_back('\0');
> }
>
> The above for loop would make unicode_string look like this:
>
> "e null a null s null y null"
>
> Is there a faster way to do this... in place maybe?

Depends what you want.

It /seems/ that you're assuming a little-endian architecture, and that the
intent is to treat unicode_string as UTF-16 encoded (via some low level cast),
and that you're assuming that the original character encoding is Latin-1 or a
subset.

That's an awful lot of assumptions.

Look in the standard library for mbcstowcs or something like that, in the C
library, or 'widen'-functions in the C++ library.

Under what seems to be your assumption of Latin-1 encoding of the 'char' string,
and an additional assumption of 16-bit 'wchar_t', you can however do


<code>
#include <iostream>
#include <string>
#include <limits.h>
using namespace std;

#define STATIC_ASSERT( x ) typedef char shouldBeTrue[(x)? 1 : -1]

STATIC_ASSERT( CHAR_BIT == 8 );
STATIC_ASSERT( sizeof( wchar_t ) == 2 );

int main()
{
string const s = "Hello";
wstring const u( s.begin(), s.end() );

wcout << u << L"\n";
}
</code>


But I don't recommend that; use the widening functions, C or C++.


Cheers & hth.,

- Alf

--
blog at <url: http://alfps.wordpress.com>

On 5 Sep., 19:05, "Francesco S. Carta" wrote:
> in place, yes: use the
> std::string::insert() method.

Or better yet, resize() to final size, assign the non-null characters
in a backwards loop and set a couple of chars to zero:

void sillify(string & io)
{
size_t len1 = io.size();
io.resize(len1*2,'\0');
for (size_t k=len1; k-->1
io[k*2] = io[k];
for (size_t k=1; k<len1; k+=2)
io[k] = '\0';
}

Cheers!
SG

SG <>, on 05/09/2010 10:17:37, wrote:

> On 5 Sep., 19:05, "Francesco S. Carta" wrote:
>> in place, yes: use the
>> std::string::insert() method.
>
> Or better yet, resize() to final size, assign the non-null characters
> in a backwards loop and set a couple of chars to zero:
>
> void sillify(string& io)
> {
> size_t len1 = io.size();
> io.resize(len1*2,'\0');
> for (size_t k=len1; k-->1
> io[k*2] = io[k];
> for (size_t k=1; k<len1; k+=2)
> io[k] = '\0';
> }

Define "better".

void smartify(string& s) {
for(int i = 1, e = s.size()*2; i < e; i+=2) {
s.insert(i, 1, '\0');
}
}

--
FSC - http://userscripts.org/scripts/show/59948
http://fscode.altervista.org - http://sardinias.com

On 5 sep, 19:27, "Francesco S. Carta" <entul...@gmail.com> wrote:
> SG <s.gesem...@gmail.com>, on 05/09/2010 10:17:37, wrote:
> > On 5 Sep., 19:05, "Francesco S. Carta" wrote:
> >> in place, yes: use the
> >> std::string::insert() method.
>
> > Or better yet, resize() to final size, assign the non-null characters
> > in a backwards loop and set a couple of chars to zero:
>
> > * * void sillify(string& *io)
> > * * {
> > * * * *size_t len1 = io.size();
> > * * * *io.resize(len1*2,'\0');
> > * * * *for (size_t k=len1; k-->1
> > * * * * * io[k*2] = io[k];
> > * * * *for (size_t k=1; k<len1; k+=2)
> > * * * * * io[k] = '\0';
> > * * }
>
> Define "better".
>
> * * *void smartify(string& s) {
> * * * * *for(int i = 1, e = s.size()*2; i < e; i+=2) {
> * * * * * * *s.insert(i, 1, '\0');
> * * * * *}
> * * *}

Faster. SG's code has linear complexity and yours is quadratic.
Readability is something else...

Marc <>, on 05/09/2010 10:54:46, wrote:

> On 5 sep, 19:27, "Francesco S. Carta"<entul...@gmail.com> wrote:
>> SG<s.gesem...@gmail.com>, on 05/09/2010 10:17:37, wrote:
>>> On 5 Sep., 19:05, "Francesco S. Carta" wrote:
>>>> in place, yes: use the
>>>> std::string::insert() method.
>>
>>> Or better yet, resize() to final size, assign the non-null characters
>>> in a backwards loop and set a couple of chars to zero:
>>
>>> void sillify(string& io)
>>> {
>>> size_t len1 = io.size();
>>> io.resize(len1*2,'\0');
>>> for (size_t k=len1; k-->1
>>> io[k*2] = io[k];
>>> for (size_t k=1; k<len1; k+=2)
>>> io[k] = '\0';
>>> }
>>
>> Define "better".
>>
>> void smartify(string& s) {
>> for(int i = 1, e = s.size()*2; i< e; i+=2) {
>> s.insert(i, 1, '\0');
>> }
>> }
>
> Faster. SG's code has linear complexity and yours is quadratic.
> Readability is something else...

Exactly. So neither is better than the other unless we associate
"better" to "more readable" or to "faster"

--
FSC - http://userscripts.org/scripts/show/59948
http://fscode.altervista.org - http://sardinias.com

Francesco S. Carta <>, on 05/09/2010 20:04:18, wrote:

> Marc <>, on 05/09/2010 10:54:46, wrote:
>
>> On 5 sep, 19:27, "Francesco S. Carta"<entul...@gmail.com> wrote:
>>> SG<s.gesem...@gmail.com>, on 05/09/2010 10:17:37, wrote:
>>>> On 5 Sep., 19:05, "Francesco S. Carta" wrote:
>>>>> in place, yes: use the
>>>>> std::string::insert() method.
>>>
>>>> Or better yet, resize() to final size, assign the non-null characters
>>>> in a backwards loop and set a couple of chars to zero:
>>>
>>>> void sillify(string& io)
>>>> {
>>>> size_t len1 = io.size();
>>>> io.resize(len1*2,'\0');
>>>> for (size_t k=len1; k-->1
>>>> io[k*2] = io[k];
>>>> for (size_t k=1; k<len1; k+=2)
>>>> io[k] = '\0';
>>>> }
>>>
>>> Define "better".
>>>
>>> void smartify(string& s) {
>>> for(int i = 1, e = s.size()*2; i< e; i+=2) {
>>> s.insert(i, 1, '\0');
>>> }
>>> }
>>
>> Faster. SG's code has linear complexity and yours is quadratic.
>> Readability is something else...
>
> Exactly. So neither is better than the other unless we associate
> "better" to "more readable" or to "faster"
>

Just for the records, a better solution, in my opinion, is to build an
appropriately sized new string and copying the original chars at the
appropriate positions - a compromise between readability and speed,
somewhat:

void foo(string& s) {
string r(s.size()*2, '\0');
for(int i = 0, e = s.size(); i < e; ++i) {
r[i*2] = s[i];
}
s.swap(r);
}

ASSUMING that the OP really wants exactly this - WRT Alf P. Steinbach's
notes in the other post.

--
FSC - http://userscripts.org/scripts/show/59948
http://fscode.altervista.org - http://sardinias.com

On 5 Sep., 20:04, Francesco S. Carta wrote:
> Marc wrote:
> > On 5 sep, 19:27, Francesco S. Carta wrote:
> >> Define "better".
> > Faster. [...]
> Exactly. So neither is better than the other unless we associate
> "better" to "more readable" or to "faster"

See the original post:

"...Is there a faster way to do this..."

Cheers!
SG

Alf P. Steinbach /Usenet <alf.p.steinbach+> wrote:
> * Brad, on 05.09.2010 18:54:
>> std::string s = "easy";
>>
>> std::string unicode_string;
>>
>> std::string::const_iterator it,
>>
>> for(it = s.begin(); it != s.end(); ++it)
>> {
>> unicode_string.push_back(*it);
>> unicode_string.push_back('\0');
>> }
>>
>> The above for loop would make unicode_string look like this:
>>
>> "e null a null s null y null"
>>
>> Is there a faster way to do this... in place maybe?
>
> Depends what you want.
>
> It /seems/ that you're assuming a little-endian architecture

No, he isn't. He is making the string UTF16LE, not assuming that the
architecture is little-endian.