Printable View
Hello, I'm new to C, and I had a question about reversing a string. I have my code to print it in reverse, but what im looking to do is actually reverse the string in memory. This is what i have so far.Any ideas?
Code:#include <stdio.h>
#include <string.h>
int main(void) {
char string[80];
int size;
printf("Enter String: ");
scanf("%s", string);
size = strlen(string);
while (size >= 0) {
printf("%c", string[size]);
size--;
}
return 0;
}
>>Any ideas?
Plenty. Some you'll be interested in, some you won't.
You've provided code that prints the string in reverse, so what have you tried for the in-memory reversing?
You need to learn to swap characters within the array. Try drawing out on paper, and think about how you'd do it, then try to translate that into code.
To do the swapping, you'll need a third char, to act as a temporary holder.Code:
This is a string\0
012345678901234567
1 - Swap number X with number Y
2 - Swap number Z with number W
etc
etc
Lets take a look at one way:
"Hello World"
If we switch the first and last letter we get
"dello WorlH"
now if we move inward one position and do it agan we get
"dlllo WoreH"
If we keep doing this we get
dlrlo WoleH
dlroo WlleH
dlroW olleH
scanf() isn't the best choice of functions for getting a string from the user. fgets() would be better. Also, your printf() is printing a '\0' as the first character. Not detrimental I guess, but it doesn't do much.
You can use this for enter strings so you dont have to use scanf and gets
Code:while( (ch = getchar()) != '\n')
{
string[i] = ch;
i++;
}
>You can use this for enter strings so you dont have to use scanf and gets
And yet, that has precisely the same problems as scanf and gets (and more). Why not just use fgets and be done with it?
using something like bubble sort will do your swap, but keep in mind that with bubble sort, in the worst case you will get the max of inversions that need to be made.
What does bubble sort have to do with reversing the order of a string? That sounds like a huge leap in the wrong direction, even though the principles of sorting can be used toward reversing a string if you think about it all squiggly.Quote:
Originally Posted by InvariantLoop
You could bubble sort, using the memory addresses as the comparison. :D I have no idea why you would want to, but it would work. ;)
[edit] Hm... It would be interesting to do it that way. It would take quite a bit of work. You'd have to map the address to the character itself. It's definately warped. I may have to try it... [/edit]
Quzah.
>It would take quite a bit of work.
Not really. Just add ampersands in the test and you're done. ;) It's somewhat interesting, but far more interesting is getting it to work generally. For example, how do you know whether an implementation stores the string with ascending or descending memory addresses? One would reverse correctly and the other would do nothing. Also more interesting would be a performance analysis. For a general function, would the performance boost of comparing large objects by address rather than by value be worth the extra work of getting the sort right? What if the objects are small, such as characters?
Still thinking about obfuscating code, eh?Quote:
Originally Posted by quzah
I'd like to see on that stored it in descending order. It goes against the grain:Quote:
Originally Posted by Prelude
I can't really envision one that would store in backwards, because the very basics of string manipulation would immediately become broken.Code:char *ptr1, *ptr2;
ptr1 = passedstring;
ptr2 = strlen( ptr1 ) + ptr1; /* now we point at the null */
Still, if such a case did exist, all you'd have to do is one simple test:
And deal with it from there by reversing the swap order.Code:if( ptr1 > ptr2 )
{
printf( "Your implementation is ass-backwards.\n" );
}
Quzah.
It's just a really messed up way of doing something, so it became interesting. ;)Quote:
Originally Posted by jEssYcAt
Quzah.
Something like this?
Code:#include <stdio.h>
#include <string.h>
void revstr(char *str)
{
struct str_s
{
char ch;
char *ptr;
} strarray[strlen(str)], temp;
int len, i, j;
for(len = 0;str[len];++len)
{
strarray[len].ch = str[len];
strarray[len].ptr = str+len;
}
for(i = 0;i < len;++i)
for(j = i+1;j < len;++j)
if(strarray[i].ptr < strarray[j].ptr)
{
memcpy(&temp, &strarray[i], sizeof(struct str_s));
memcpy(&strarray[i], &strarray[j], sizeof(struct str_s));
memcpy(&strarray[j], &temp, sizeof(struct str_s));
}
for(i = 0;i < len;++i)
str[i] = strarray[i].ch;
str[i] = '\0';
}
int main(void)
{
char str[] = "abcdefg";
printf("String: %s\n", str);
revstr(str);
printf("Reversed: %s\n", str);
return 0;
}
Code:itsme@dreams:~/C$ ./revstr
String: abcdefg
Reversed: gfedcba
Dealing with the first half of the thread:
Snippets anyone? :D
> http://www.cprogramming.com/snippets...ount=30&page=0
I got a comment about my code that it was C99. Just for my own understanding, can someone clear up for me what's C99 about it? Is it the way I declared strarray? I really should get my hands on some standards books ;)
Thanks
Here's another one. It uses the XOR trick, but you can use another temporary variable to swap characters.
PS: itsme86: Yes, it's the way you declared strarray (array size computed in run-time).Code:char *revstr(char *const string)
{
register char *begin;
register char *end;
const size_t length = strlen(string);
for (begin = string, end = string + length - 1; begin < end; begin++, end--)
*begin ^= *end ^= *begin ^= *end;
return string;
}
You know there's really no point in ever using the 'register' keyword, right?
Quzah.
> *begin ^= *end ^= *begin ^= *end;
Oh please, not this nonsense again!!!!
http://www.eskimo.com/~scs/C-faq/q10.3.html
Pay REALLY close attention now - read the bit which says
"and the ``obvious'' supercompressed implementation for integral types a^=b^=a^=b is illegal due to multiple side-effects; see question 3.2)."
I seem to remember a post of mine some time ago which showed that the compiler was way smarter than the "clever" programmer in that the blindingly obvious "use a temporary variable" actually produced the smallest code, and that all these arithmetic and logical tricks produced longer instruction sequences.
Quote:
Originally Posted by itsme86
Variable-size arrays in C have always been (pre-C99) a no-no:
(You do realize, don't you, that there's a little elf ---near the East Pole--- who collects a royalty of .01 euros for every use of malloc() in a commercial program? If everybody started using variable-length arrays, he would have to declare bankruptcy. The next thing you know, he would given his own reality-TV show. Too horrible to imagine!)Code:void revstr(char *str)
{
struct str_s
{
char ch;
char *ptr;
} strarray[strlen(str)], temp;
Regards,
Dave