shorten string length by 1

[John Smith]

I want to shorten a string by replacing the last character by '\0'.

The following code displays the string. It works fine. It's in a
loop and different strings are displayed without problems.
-----------------------------------------------------------
temp= strlen(aGroup);
for (i=0; i< temp;i++)
printf(" %d %d %c\n", i+1,temp,aGroup[i]);
---------------------------------------------------------

To replace the last character by '\0', I have tried

aGroup[i-1]='\0';

or
temp--;
aGroup[temp]='\0';

or
aGroup[temp-1]='\0';

Though there is no compiling error, the program crashed when ran
(I was asked whether to send error report to Microsoft. Same error
for all three.)

But "aGroup[22]='\0';" works (I knew the length is greater than 22.)

What gives? This is on VC++ 6.0.

[Jason]

John Smith wrote:

I want to shorten a string by replacing the last character by '\0'.

The following code displays the string. It works fine. It's in a
loop and different strings are displayed without problems.
-----------------------------------------------------------
temp= strlen(aGroup);
for (i=0; i< temp;i++)
printf(" %d %d %c\n", i+1,temp,aGroup[i]);
---------------------------------------------------------

To replace the last character by '\0', I have tried

aGroup[i-1]='\0';

or
temp--;
aGroup[temp]='\0';

or
aGroup[temp-1]='\0';

Though there is no compiling error, the program crashed when ran
(I was asked whether to send error report to Microsoft. Same error
for all three.)

But "aGroup[22]='\0';" works (I knew the length is greater than 22.)

What gives? This is on VC++ 6.0.

Verify that aGroup has been properly declared, and that it is
suffiently large enough to store the string you are copying into it.
Perhaps you are overflowing a buffer, or forgot to properly call
malloc?

-Jason
-Jason

[John Smith]

Jason wrote:

John Smith wrote:

I want to shorten a string by replacing the last character by '\0'.

The following code displays the string. It works fine. It's in a
loop and different strings are displayed without problems.
-----------------------------------------------------------
temp= strlen(aGroup);
for (i=0; i< temp;i++)
printf(" %d %d %c\n", i+1,temp,aGroup[i]);
---------------------------------------------------------

To replace the last character by '\0', I have tried

aGroup[i-1]='\0';

or
temp--;
aGroup[temp]='\0';

or
aGroup[temp-1]='\0';

Though there is no compiling error, the program crashed when ran
(I was asked whether to send error report to Microsoft. Same error
for all three.)

But "aGroup[22]='\0';" works (I knew the length is greater than 22.)

What gives? This is on VC++ 6.0.

Verify that aGroup has been properly declared, and that it is
suffiently large enough to store the string you are copying into it.
Perhaps you are overflowing a buffer, or forgot to properly call
malloc?

-Jason
-Jason

Thanks for the reply.

As I said. The program worked fine until I added the code (any one
of the three) to replace the last character. I think this should
rule out the potential problems you mentioned.

BTW, aGroup is declared as "char aGroup[2048];" which is probably
10 times larger than what it can be.

[Jason]

John Smith wrote:

BTW, aGroup is declared as "char aGroup[2048];" which is probably
10 times larger than what it can be.

Could you post the actual code? Without further information I'm afraid
I won't be able to assist you.

-Jason

[Barry Schwarz]

On Fri, 15 Apr 2005 00:43:41 GMT, John Smith <js****@company.com>
wrote:

I want to shorten a string by replacing the last character by '\0'.

snip incomplete code
Though there is no compiling error, the program crashed when ran
(I was asked whether to send error report to Microsoft. Same error
for all three.)

But "aGroup[22]='\0';" works (I knew the length is greater than 22.)

What gives? This is on VC++ 6.0.

Show the definition and initialization of aGroup please.
<<Remove the del for email>>

[Keith Thompson]

John Smith <js****@company.com> writes:
[...]

As I said. The program worked fine until I added the code (any one
of the three) to replace the last character. I think this should
rule out the potential problems you mentioned.
No, "The program worked fine" doesn't rule out anything. Your recent
changes could simply have changed it from undefined behavior that
happens to be harmless to undefined behavior that blows things up.
BTW, aGroup is declared as "char aGroup[2048];" which is probably
10 times larger than what it can be.

If aGroup contains a valid string, the following should shorten it by
one character:

aGroup[strlen(aGroup)-1] = '\0';

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[websnarf]

Keith Thompson wrote:

John Smith <js****@company.com> writes:

BTW, aGroup is declared as "char aGroup[2048];" which is probably
10 times larger than what it can be.

You mean its 10 times larger than necessary most of the time, and
insufficient for some marginal cases. So its neither sufficient or
efficient.
If aGroup contains a valid string, the following should shorten it by
one character:

aGroup[strlen(aGroup)-1] = '\0';

Excuse me? No. Try the following:

aGroup[strlen(aGroup) - (aGroup[0] != '\0')] = '\0';

Using Bstrlib, this is somewhat more understandable:

bdelete(b_aGroup, blength(b_aGroup) - 1, 1);

---
Paul Hsieh
http://www.pobox.com/~qed/
http://bstring.sf.net/

[Mac]

On Fri, 15 Apr 2005 15:49:26 -0400, Joe Wright wrote:

John Smith wrote:

Jason wrote:

John Smith wrote:
I want to shorten a string by replacing the last character by '\0'.

The following code displays the string. It works fine. It's in a
loop and different strings are displayed without problems.
-----------------------------------------------------------
temp= strlen(aGroup);
for (i=0; i< temp;i++)
printf(" %d %d %c\n", i+1,temp,aGroup[i]);
---------------------------------------------------------

To replace the last character by '\0', I have tried

aGroup[i-1]='\0';

or
temp--;
aGroup[temp]='\0';

or
aGroup[temp-1]='\0';

Though there is no compiling error, the program crashed when ran
(I was asked whether to send error report to Microsoft. Same error
for all three.)

But "aGroup[22]='\0';" works (I knew the length is greater than 22.)

What gives? This is on VC++ 6.0.
Verify that aGroup has been properly declared, and that it is
suffiently large enough to store the string you are copying into it.
Perhaps you are overflowing a buffer, or forgot to properly call
malloc?

-Jason
-Jason

Thanks for the reply.

As I said. The program worked fine until I added the code (any one
of the three) to replace the last character. I think this should
rule out the potential problems you mentioned.

BTW, aGroup is declared as "char aGroup[2048];" which is probably
10 times larger than what it can be.

#include <stdio.h>
#include <string.h>

int main(void)
{
char aGroup[2048];
int i;
strcpy(aGroup, "Hello Sailor");
i = strlen(aGroup);
while (i--) {
puts(aGroup);
aGroup[i] = '\0';
}
return 0;
}

Why is this thread so long?

Is this like a Zen Koan or something? Does the behavior of this program
somehow shed light on what is wrong with the OP's code fragment? If so, I
don't get it. :-(

--Mac

[Mark McIntyre]

On Fri, 15 Apr 2005 21:26:57 GMT, in comp.lang.c , Keith Thompson
<ks***@mib.org> wrote:

Mark McIntyre <ma**********@spamcop.net> writes:

On 15 Apr 2005 01:18:50 -0700, in comp.lang.c , we******@gmail.com
wrote:

If aGroup contains a valid string, the following should shorten it by
one character:

aGroup[strlen(aGroup)-1] = '\0';

Excuse me? No. Try the following:

aGroup[strlen(aGroup) - (aGroup[0] != '\0')] = '\0';
Re-read what keith said.

Actually, websnarf caught something that I missed. If aGroup contains
a valid string of length 0, my code will write before the beginning of
the array, invoking undefined behavior.

Yes, I realise thats what he was trying to trap. I don't consider a
string of length zero to be a valid string however. YMMV, as may
Paul's.
But I don't see the need to put everything into the index expression.

me neither - it was unnecessarily obfuscated and would have failed a
code review at my shop.
--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.ungerhu.com/jxh/clc.welcome.txt>

----== Posted via Newsfeeds.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeeds.com The #1 Newsgroup Service in the World! 120,000+ Newsgroups
----= East and West-Coast Server Farms - Total Privacy via Encryption =----

[Keith Thompson]

Mark McIntyre <ma**********@spamcop.net> writes:
[...]

Yes, I realise thats what he was trying to trap. I don't consider a
string of length zero to be a valid string however. YMMV, as may
Paul's.

Of course a string of length zero is a valid string; why wouldn't it
be? Almost any function in the standard library that accepts a string
will happily accept an empty string.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[pete]

Mac wrote:

On Fri, 15 Apr 2005 15:49:26 -0400, Joe Wright wrote:

John Smith wrote:

BTW, aGroup is declared as "char aGroup[2048];" which is probably
10 times larger than what it can be.

#include <stdio.h>
#include <string.h>

int main(void)
{
char aGroup[2048];
int i;
strcpy(aGroup, "Hello Sailor");
i = strlen(aGroup);
while (i--) {
puts(aGroup);
aGroup[i] = '\0';
}
return 0;
}

Why is this thread so long?

Is this like a Zen Koan or something?
Does the behavior of this program
somehow shed light on what is wrong with the OP's code fragment?
If so, I don't get it. :-(

The program takes advantage of the fact that there is
nothing extraordinary about a 2048 byte automatic object,
contrary to what John Smith suggested.
The program shortens string length by 1,
and the program is portable.

--
pete

[pete]

Keith Thompson wrote:

Mark McIntyre <ma**********@spamcop.net> writes:
[...]

Yes, I realise thats what he was trying to trap. I don't consider a
string of length zero to be a valid string however. YMMV, as may
Paul's.

Of course a string of length zero is a valid string; why wouldn't it
be? Almost any function in the standard library that accepts a string
will happily accept an empty string.

Almost?

--
pete

[Keith Thompson]

pete <pf*****@mindspring.com> writes:

Keith Thompson wrote:

Mark McIntyre <ma**********@spamcop.net> writes:
[...]

> Yes, I realise thats what he was trying to trap. I don't consider a
> string of length zero to be a valid string however. YMMV, as may
> Paul's.

Of course a string of length zero is a valid string; why wouldn't it
be? Almost any function in the standard library that accepts a string
will happily accept an empty string.

Almost?

I was thinking of the mode argument to fopen(). An empty string is
invalid not because it's empty, but because it's not one of the
allowed forms. There may be other examples.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Mark McIntyre]

On Sat, 16 Apr 2005 11:06:14 GMT, in comp.lang.c , Keith Thompson
<ks***@mib.org> wrote:

Mark McIntyre <ma**********@spamcop.net> writes:
[...]

Yes, I realise thats what he was trying to trap. I don't consider a
string of length zero to be a valid string however. YMMV, as may
Paul's.
Of course a string of length zero is a valid string; why wouldn't it
be?

Because it contains no characters.
Almost any function in the standard library that accepts a string
will happily accept an empty string.

Sure. That doesn't mean that /I/ consider a zero length string to be a
valid string. Personally I would have trapped that long before trying
to manipulate it, so Paul's obfuscated code would have been quite
gratuitous.

--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.ungerhu.com/jxh/clc.welcome.txt>

----== Posted via Newsfeeds.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeeds.com The #1 Newsgroup Service in the World! 120,000+ Newsgroups
----= East and West-Coast Server Farms - Total Privacy via Encryption =----

[Mac]

On Sat, 16 Apr 2005 12:19:03 +0000, pete wrote:

Mac wrote:

On Fri, 15 Apr 2005 15:49:26 -0400, Joe Wright wrote:

> John Smith wrote: >> BTW, aGroup is declared as "char aGroup[2048];" which is probably
>> 10 times larger than what it can be.
>
>
> #include <stdio.h>
> #include <string.h>
>
> int main(void)
> {
> char aGroup[2048];
> int i;
> strcpy(aGroup, "Hello Sailor");
> i = strlen(aGroup);
> while (i--) {
> puts(aGroup);
> aGroup[i] = '\0';
> }
> return 0;
> }
>
> Why is this thread so long?

Is this like a Zen Koan or something?
Does the behavior of this program
somehow shed light on what is wrong with the OP's code fragment?
If so, I don't get it. :-(

The program takes advantage of the fact that there is
nothing extraordinary about a 2048 byte automatic object,
contrary to what John Smith suggested.
The program shortens string length by 1,
and the program is portable.

I read what John Smith wrote a little differently. According to my
reading, he was emphasizing that 2048 bytes is 10 times longer than the
actual string can be, so there is no danger of an overflow. I could be
wrong.

Anyway, John Smith is obstinate and resistant to suggestions that could
help him, so I don't want to defend him. And I guess I don't really want
to say anything more in this thread.

HAND. ;-)

--Mac

[Keith Thompson]

Mark McIntyre <ma**********@spamcop.net> writes:

On Sat, 16 Apr 2005 11:06:14 GMT, in comp.lang.c , Keith Thompson
<ks***@mib.org> wrote:

Mark McIntyre <ma**********@spamcop.net> writes:
[...]

Yes, I realise thats what he was trying to trap. I don't consider a
string of length zero to be a valid string however. YMMV, as may
Paul's.

Of course a string of length zero is a valid string; why wouldn't it
be?

Because it contains no characters.

You're using the term "valid" in a very odd sense.

An empty string may be invalid for some purposes. A string containing
non-printable characters, or one containing the letter 'q', may be
invalid for other purposes.

If you mean that an empty string is invalid in the limited context of
wanting to shorten a string by 1 character, I agree. (Note that if
the initial string has a length of 1, the *result* is a perfectly
valid empty string.)

Would you have the compiler issue a warning on
char *s = "";
or
char s[] = "";
?

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Mark McIntyre]

On Sun, 17 Apr 2005 08:03:09 GMT, in comp.lang.c , Keith Thompson
<ks***@mib.org> wrote:

Mark McIntyre <ma**********@spamcop.net> writes:

Because it contains no characters.
You're using the term "valid" in a very odd sense.

How so? The context was how to shorten a string by one character. I'm
unsure how a zero length string can be valid for that operation. And
FWIW I consider it very odd to think of a string with zero length as
being a valid one.
An empty string may be invalid for some purposes.
such as the one under discussion. And even setting aside the context,
I still don't consider a character array with only a null in it to be
a string. YMMV.
Would you have the compiler issue a warning on
char *s = "";
or
char s[] = "";

Nope. Why should I? Merely because its (in my opinion) not a
well-formed string, doesn't make it any the less a useful code
construct. Come on, try not to be so silly.

--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.ungerhu.com/jxh/clc.welcome.txt>

[Keith Thompson]

Mark McIntyre <ma**********@spamcop.net> writes:

On Sun, 17 Apr 2005 08:03:09 GMT, in comp.lang.c , Keith Thompson
<ks***@mib.org> wrote: [...]

An empty string may be invalid for some purposes.

such as the one under discussion.

If you were just talking about the particular case under discussion,
I'd agree with you.
And even setting aside the context,
I still don't consider a character array with only a null in it to be
a string. YMMV.

That's just wrong. The definition of "string" in C99 7.1.1p1 could be
interpreted to exclude empty strings, but it's obviously the intent
that the empty string is a string. If you want to refer to non-empty
strings, find another word.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Gergö Barany]

Mark McIntyre wrote:

On Sun, 17 Apr 2005 08:03:09 GMT, in comp.lang.c , Keith Thompson
<ks***@mib.org> wrote:

You're using the term "valid" in a very odd sense.

How so? The context was how to shorten a string by one character. I'm
unsure how a zero length string can be valid for that operation. And
FWIW I consider it very odd to think of a string with zero length as
being a valid one.

How would you implement this shortening operation, then? Surely
shortening a one-character string by one character would yield the empty
string. But that cannot be, since the empty string is invalid...
Gergo
--
The key elements in human thinking are not numbers but labels of fuzzy sets.
-- L. Zadeh

[Richard Bos]

=?ISO-8859-1?Q?Gerg=F6_Barany?= <ge***@tud.at> wrote:

Mark McIntyre wrote:

On Sun, 17 Apr 2005 08:03:09 GMT, in comp.lang.c , Keith Thompson
<ks***@mib.org> wrote:

You're using the term "valid" in a very odd sense.

How so? The context was how to shorten a string by one character. I'm
unsure how a zero length string can be valid for that operation. And
FWIW I consider it very odd to think of a string with zero length as
being a valid one.

How would you implement this shortening operation, then? Surely
shortening a one-character string by one character would yield the empty
string. But that cannot be, since the empty string is invalid...

The solution is obvious: a one-character string is not a valid string,
either.

Richard

[Alan Balmer]

On Tue, 19 Apr 2005 06:19:27 GMT, rl*@hoekstra-uitgeverij.nl (Richard
Bos) wrote:

=?ISO-8859-1?Q?Gerg=F6_Barany?= <ge***@tud.at> wrote:

Mark McIntyre wrote:

> On Sun, 17 Apr 2005 08:03:09 GMT, in comp.lang.c , Keith Thompson
> <ks***@mib.org> wrote:
>>You're using the term "valid" in a very odd sense.
>
> How so? The context was how to shorten a string by one character. I'm
> unsure how a zero length string can be valid for that operation. And
> FWIW I consider it very odd to think of a string with zero length as
> being a valid one.

How would you implement this shortening operation, then? Surely
shortening a one-character string by one character would yield the empty
string. But that cannot be, since the empty string is invalid...

The solution is obvious: a one-character string is not a valid string,
either.

Making it trivial to prove by induction that there are no valid
strings.

--
Al Balmer
Balmer Consulting
re************************@att.net

[Richard Bos]

Alan Balmer <al******@att.net> wrote:

On Tue, 19 Apr 2005 06:19:27 GMT, rl*@hoekstra-uitgeverij.nl (Richard
Bos) wrote:

=?ISO-8859-1?Q?Gerg=F6_Barany?= <ge***@tud.at> wrote:

Mark McIntyre wrote:
> On Sun, 17 Apr 2005 08:03:09 GMT, in comp.lang.c , Keith Thompson
> <ks***@mib.org> wrote:
>>You're using the term "valid" in a very odd sense.
>
> How so? The context was how to shorten a string by one character. I'm
> unsure how a zero length string can be valid for that operation. And
> FWIW I consider it very odd to think of a string with zero length as
> being a valid one.

How would you implement this shortening operation, then? Surely
shortening a one-character string by one character would yield the empty
string. But that cannot be, since the empty string is invalid...

The solution is obvious: a one-character string is not a valid string,
either.

Making it trivial to prove by induction that there are no valid
strings.

Isn't life beautifully simple, sometimes <g>?

Richard

[Mark McIntyre]

On Tue, 19 Apr 2005 08:16:52 -0700, in comp.lang.c , Alan Balmer
<al******@att.net> wrote:

On Tue, 19 Apr 2005 06:19:27 GMT, rl*@hoekstra-uitgeverij.nl (Richard
Bos) wrote:

=?ISO-8859-1?Q?Gerg=F6_Barany?= <ge***@tud.at> wrote:

How would you implement this shortening operation, then? Surely
shortening a one-character string by one character would yield the empty
string. But that cannot be, since the empty string is invalid...

The solution is obvious: a one-character string is not a valid string,
either.

Making it trivial to prove by induction that there are no valid
strings.

Er, only if your induction process is broken. The same logic
demonstrates that all numbers are equal to zero, and that there are no
humans in the galaxy.
--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.ungerhu.com/jxh/clc.welcome.txt>

[Alan Balmer]

On Tue, 19 Apr 2005 20:24:41 +0100, Mark McIntyre
<ma**********@spamcop.net> wrote:

On Tue, 19 Apr 2005 08:16:52 -0700, in comp.lang.c , Alan Balmer
<al******@att.net> wrote:

On Tue, 19 Apr 2005 06:19:27 GMT, rl*@hoekstra-uitgeverij.nl (Richard
Bos) wrote:

=?ISO-8859-1?Q?Gerg=F6_Barany?= <ge***@tud.at> wrote:

How would you implement this shortening operation, then? Surely
shortening a one-character string by one character would yield the empty
string. But that cannot be, since the empty string is invalid...

The solution is obvious: a one-character string is not a valid string,
either.

Making it trivial to prove by induction that there are no valid
strings.

Er, only if your induction process is broken. The same logic
demonstrates that all numbers are equal to zero, and that there are no
humans in the galaxy.

Of course.

It's not the induction process - it's the premise.

--
Al Balmer
Balmer Consulting
re************************@att.net

[Mark McIntyre]

On Tue, 19 Apr 2005 13:35:44 -0700, in comp.lang.c , Alan Balmer
<al******@att.net> wrote:

On Tue, 19 Apr 2005 20:24:41 +0100, Mark McIntyre
<ma**********@spamcop.net> wrote:

Er, only if your induction process is broken. The same logic
demonstrates that all numbers are equal to zero, and that there are no
humans in the galaxy.

Of course.

It's not the induction process - it's the premise.

For myself, I prefer D Adams' proof of the above.
--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.ungerhu.com/jxh/clc.welcome.txt>