std::string::np os always < std::string::si ze() ?

[Christopher Pisz]

Is std::string::np os always going to be less than any std::string 's size()?

I am trying to handle a replacement of all occurances of a substr, in which
the replacement also contains the substr. Yick. All I could come up with is:

#include <string>

int main()
{
std::string text;
text = "\nThis is a test line with newlines\n<-here and \n<-here and
\n\n<-two here";

// Format the text
std::string formattedText(t ext);

// Change every occurrance of "\n" to "\r\n"
std::string::si ze_type index = 0;

do
{
index = formattedText.f ind('\n', index);
if( index != std::string::np os )
{
formattedText.i nsert(index, "\r");
index += 2;
}
} while( index < formattedText.s ize() );

// debugging contents of formattedText here

return 0;
}

However, it depends on std::string::np os always being less than the size of
the string and I am not certain whether that is safe or not.

[Dreamlax]

On Jan 10, 4:52 pm, "Christophe r Pisz" <some...@somewh ere.netwrote:

Is std::string::np os always going to be less than any std::string 's size()?

I am trying to handle a replacement of all occurances of a substr, in which
the replacement also contains the substr. Yick. All I could come up with is:

#include <string>

int main()
{
std::string text;
text = "\nThis is a test line with newlines\n<-here and \n<-here and
\n\n<-two here";

// Format the text
std::string formattedText(t ext);

// Change every occurrance of "\n" to "\r\n"
std::string::si ze_type index = 0;

do
{
index = formattedText.f ind('\n', index);
if( index != std::string::np os )
{
formattedText.i nsert(index, "\r");
index += 2;
}
} while( index < formattedText.s ize() );

// debugging contents of formattedText here

return 0;

}

However, it depends on std::string::np os always being less than the size of
the string and I am not certain whether that is safe or not.

I know this is a horrible solution, but what about something along the
lines copying the contents of the string to another string?
int i;

for (i = 0; i < string1.size(); i++)
{
if (string1[i] == '\n') string2 += "\r\n";
else string2 += string1[i];
}
It's slow and bloated it does the job in a straightforward way.

[Abhishek Padmanabh]

On Jan 10, 8:52*am, "Christophe r Pisz" <some...@somewh ere.netwrote:

Is std::string::np os always going to be less than any std::string 's size()?

I am trying to handle a replacement of all occurances of a substr, in which
the replacement also contains the substr. Yick. All I could come up with is:

#include <string>

int main()
{
* *std::string text;
* *text = "\nThis is a test line with newlines\n<-here and \n<-here and
\n\n<-two here";

* *// Format the text
* *std::string formattedText(t ext);

* *// Change every occurrance of "\n" to "\r\n"
* *std::string::s ize_type index = 0;

* *do
* *{
* * * index = formattedText.f ind('\n', index);
* * * if( index != std::string::np os )
* * * {
* * * * *formattedText. insert(index, "\r");
* * * * *index += 2;
* * * }
* *} while( index < formattedText.s ize() );

* *// debugging contents of formattedText here

* *return 0;

}

However, it depends on std::string::np os always being less than the size of
the string and I am not certain whether that is safe or not.

It is ok/safe. An std::string cannot have a length() (since it is
std::string, size()) greater than std::string::np os. So, your code
should be perfectly fine, it will always exit the do-while when all
instances of '\n' have been dealt with.

[Abhishek Padmanabh]

On Jan 10, 1:29*pm, Abhishek Padmanabh <abhishek.padma [e-mail]>
wrote:

On Jan 10, 8:52*am, "Christophe r Pisz" <some...@somewh ere.netwrote:

Is std::string::np os always going to be less than any std::string 's size()?

I am trying to handle a replacement of all occurances of a substr, in which
the replacement also contains the substr. Yick. All I could come up withis:

#include <string>

int main()
{
* *std::string text;
* *text = "\nThis is a test line with newlines\n<-here and \n<-here and
\n\n<-two here";

* *// Format the text
* *std::string formattedText(t ext);

* *// Change every occurrance of "\n" to "\r\n"
* *std::string::s ize_type index = 0;

* *do
* *{
* * * index = formattedText.f ind('\n', index);
* * * if( index != std::string::np os )
* * * {
* * * * *formattedText. insert(index, "\r");
* * * * *index += 2;
* * * }
* *} while( index < formattedText.s ize() );

* *// debugging contents of formattedText here

* *return 0;

}

However, it depends on std::string::np os always being less than the sizeof
the string and I am not certain whether that is safe or not.

It is ok/safe. An std::string cannot have a length() (since it is
std::string, size()) greater than std::string::np os. So, your code
should be perfectly fine, it will always exit the do-while when all
instances of '\n' have been dealt with.- Hide quoted text -

- Show quoted text -

Ideally, you should handle the length_error exception.

[Jim Langston]

Christopher Pisz wrote:

Is std::string::np os always going to be less than any std::string 's
size()?

Actually, the other way around. std::string::np os is always going to be
greater than sny std::string's size.

I am trying to handle a replacement of all occurances of a substr, in
which the replacement also contains the substr. Yick. All I could
come up with is:
#include <string>

int main()
{
std::string text;
text = "\nThis is a test line with newlines\n<-here and \n<-here and
\n\n<-two here";

// Format the text
std::string formattedText(t ext);

// Change every occurrance of "\n" to "\r\n"
std::string::si ze_type index = 0;

do
{
index = formattedText.f ind('\n', index);
if( index != std::string::np os )
{
formattedText.i nsert(index, "\r");
index += 2;
}
} while( index < formattedText.s ize() );

// debugging contents of formattedText here

return 0;
}

However, it depends on std::string::np os always being less than the
size of the string and I am not certain whether that is safe or not.

Your code is perfectly fine, however, your while statment can simply be
changed to:

} while ( index != std::string::np os );

And you could even simplify it a bit by rearranging it.

index = 0;
while ( ( index = formattedText.f ind('n', index ) != std::string::np os )
{
formattedText.i nsert(index, "\r");
index += 2;
}

Now you don't need the if statmeent and to me it is cleaner code.
--
Jim Langston
ta*******@rocke tmail.com

[James Kanze]

On Jan 10, 4:52 am, "Christophe r Pisz" <some...@somewh ere.netwrote:

Is std::string::np os always going to be less than any
std::string 's size()?

It's always going to be greater.

I am trying to handle a replacement of all occurances of a
substr, in which the replacement also contains the substr.
Yick. All I could come up with is:

#include <string>

int main()
{
std::string text;
text = "\nThis is a test line with newlines\n<-here and \n<-here and
\n\n<-two here";

// Format the text
std::string formattedText(t ext);

// Change every occurrance of "\n" to "\r\n"
std::string::si ze_type index = 0;

do
{
index = formattedText.f ind('\n', index);
if( index != std::string::np os )
{
formattedText.i nsert(index, "\r");
index += 2;
}
} while( index < formattedText.s ize() );

// debugging contents of formattedText here
return 0;
}

However, it depends on std::string::np os always being less
than the size of the string and I am not certain whether that
is safe or not.

Your code should work, although I'd definitely use a while or a
for, rather than a do...while:

for ( size_t pos = text.find( '\n' ) ;
pos != std::string::np os ;
pos = text.find( '\n', pos + 2 ) ) {
text.insert( pos, '\r' ) ;
}

But generally, I'd rather not do this sort of thing in place.
Something more like:

std::string
convertToDos( std::string const& source )
{
std::string result ;
for ( std::string::co nst_iterator it = source.begin() ;
it != source.end() ;
++ it ) {
switch (*it) {
case '\n' :
result += "\r\n" ;
break ;

default :
result += *it ;
break ;
}
}
return result ;
}

This seems a lot cleaner to me, despite having more lines of
code, and is probably faster as well (less copying). If the
strings are very long, and performance is still a problem, you
can add the following after the definition of result:

result.reserve( source.size()
+ std::count( source.begin(), source.end(),
'\n' ) ;

. Unless the strings are very long, however, it probably won't
matter.)

--
James Kanze (GABI Software) mailto:ja****** ***@gmail.com
Conseils en informatique orient�e objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place S�mard, 78210 St.-Cyr-l'�cole, France, [phone]

[James Kanze]

On Jan 10, 10:47 am, "Jim Langston" <tazmas...@rock etmail.comwrote :

[...]

And you could even simplify it a bit by rearranging it.

index = 0;
while ( ( index = formattedText.f ind('n', index ) != std::string::np os )
{
formattedText.i nsert(index, "\r");
index += 2;
}

Which has a nested assignment guaranteed to make the code more
difficult to read. As posted elsewhere, I'd do it with a for:

for ( size_t pos = formattedText.f ind( '\n' ) ;
pos != std::string::np os ;
pos = formattedText.f ind( '\n', pos + 2 ) ) {
formattedText.i nsert( pos, '\r' ) ;
}

Everything where a reader would expect to find it.

Now you don't need the if statmeent and to me it is cleaner code.

An assignment nested in a condition will never be considered
clean code. A statement should do one, and only one thing.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Jim Langston]

James Kanze wrote:

On Jan 10, 10:47 am, "Jim Langston" <tazmas...@rock etmail.comwrote :

[...]

>And you could even simplify it a bit by rearranging it.

>index = 0;
while ( ( index = formattedText.f ind('n', index ) !=
std::string::n pos ) {
formattedText.i nsert(index, "\r");
index += 2;
}

Which has a nested assignment guaranteed to make the code more
difficult to read. As posted elsewhere, I'd do it with a for:

for ( size_t pos = formattedText.f ind( '\n' ) ;
pos != std::string::np os ;
pos = formattedText.f ind( '\n', pos + 2 ) ) {
formattedText.i nsert( pos, '\r' ) ;
}

Everything where a reader would expect to find it.

I would like others opionion on which they consider cleaner code.

I do ( var = something ) == something
all the time, and have always considered it clean.

Opinions?

>Now you don't need the if statmeent and to me it is cleaner code.

An assignment nested in a condition will never be considered
clean code. A statement should do one, and only one thing.

--
Jim Langston
ta*******@rocke tmail.com

[Ron AF Greve]

Hi,

Use that all the time too, nothing wrong with it, in my opinion. But then
again every developer seems to have his/her own rules :-)
Regards, Ron AF Greve

http://www.InformationSuperHighway.eu

"Jim Langston" <ta*******@rock etmail.comwrote in message
news:OQ******** ****@newsfe06.l ga...

James Kanze wrote:

>On Jan 10, 10:47 am, "Jim Langston" <tazmas...@rock etmail.comwrote :

[...]

>>And you could even simplify it a bit by rearranging it.

>>index = 0;
while ( ( index = formattedText.f ind('n', index ) !=
std::string:: npos ) {
formattedText.i nsert(index, "\r");
index += 2;
}

Which has a nested assignment guaranteed to make the code more
difficult to read. As posted elsewhere, I'd do it with a for:

for ( size_t pos = formattedText.f ind( '\n' ) ;
pos != std::string::np os ;
pos = formattedText.f ind( '\n', pos + 2 ) ) {
formattedText.i nsert( pos, '\r' ) ;
}

Everything where a reader would expect to find it.

I would like others opionion on which they consider cleaner code.

I do ( var = something ) == something
all the time, and have always considered it clean.

Opinions?

>>Now you don't need the if statmeent and to me it is cleaner code.

An assignment nested in a condition will never be considered
clean code. A statement should do one, and only one thing.

--
Jim Langston
ta*******@rocke tmail.com

[James Kanze]

On Jan 10, 11:17 pm, "Jim Langston" <tazmas...@rock etmail.comwrote :

James Kanze wrote:

On Jan 10, 10:47 am, "Jim Langston" <tazmas...@rock etmail.comwrote :

[...]

And you could even simplify it a bit by rearranging it.

index = 0;
while ( ( index = formattedText.f ind('n', index ) !=
std::string::np os ) {
formattedText.i nsert(index, "\r");
index += 2;
}

Which has a nested assignment guaranteed to make the code
more difficult to read. As posted elsewhere, I'd do it with
a for:

for ( size_t pos = formattedText.f ind( '\n' ) ;
pos != std::string::np os ;
pos = formattedText.f ind( '\n', pos + 2 ) ) {
formattedText.i nsert( pos, '\r' ) ;
}

Everything where a reader would expect to find it.

I would like others opionion on which they consider cleaner code.

I do ( var = something ) == something
all the time, and have always considered it clean.

Opinions?

In addition to opinions, there are measurable differences in
readability. When scanning the code rapidly, "if" or "while"
means flow control, not state change. Doing too many things in
a single statement leads to obfuscation.

Obviously, it's not an absolute rule, and must be weighed
against other "obfuscatio ns" that obeying it might introduce.
And there are idioms so ubiquious that they are recognized
despite breaking the rule: I write things like:
while ( std::getline( source, line ) ) ...
, for example, even though it violates the rule, because it is
so ubiquious that doing it any other way raises questions. I
would hope, however, that we're past the time when people
thought it clever to put the entire function in a single
condition---things like:
while ( *p ++ = *q ++ );
or even
while ( (*p ++ = *q ++) != 0 );
(The first is drawn from the original K&R, and even back then,
the authors expressed some doubts as to its advisability.)

In this particular case, there's absolutely no reason to "hide"
the update of index. Especially as you also have a specific
update at the end of the while, where people would normally look
for it: your loop looks like a classical "while" (which I would
normally write as a for), with update of the control variable at
the end of the loop, and then you sneek in an additional update
in the conditional expression.

In an ideal world, to find where a variable is being modified,
it would be sufficient to scan down the file looking at the
first token in each line. Obviously, that ideal isn't really
attainable, but you shouldn't have to search into the middle of
a complicated expression either.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]