Reverse String in C (w/o STL or New Buffer)

[bwhiteman]

I'm new to the language, and need help developing a C function which will reverse a string in place and meet the following criteria:

a) You cannot use the STL Library. B) You cannot allocate another buffer. (i.e. it must be reversed in place) C) You can only use ANSI C available functions.

Any help would be greatly appreciated.

[redhead]

one thing comes to mind

 //C++
#include <iostream>
#include <string>
void reverse(std::string &str)
{
    char tmp;
    for(int i=str.size()-1, j=0; i > j; i--, ++j)
    {
        tmp=str[i];
        str[i]=str[j];
        str[j]=tmp; 
    }
}

int main(){
  std::string foo("string");
  std::cout << foo << std::endl;
  reverse(foo);
  std::cout << foo << std::endl;
  return 0;
}

/* C */
#include <stdio.h>
#include <string.h>

void reverse(char str[])
{
    char tmp;
    int i = strlen(str)-1, j=0;
    for(; i > j; i--, ++j)
    {
        tmp=str[i];
        str[i]=str[j];
        str[j]=tmp; 
    }
}

int main(){
  char foo[] = "string";
  printf("%s\n", foo);
  reverse(foo);
  printf("%s\n", foo);
  return 0;
}

[bwhiteman]

Thanks redhead. I was also considering using a single char variable to swap characters, but I thought that might violate not being able to "allocate another buffer." What do you think?

[redhead]

It's the only way, how would you ever remember what charactor you swaped out to begin with ?? Besides a single char isn't allocating extra space, on the other hand something like:

char * res_str = (char*) malloc(strlen(orig_str)*sizeof(char));
/* or */
char res_str[strlen(orig_str)];

would be allocating extra buffer space...

[bwhiteman]

That makes sense to me. Thanks again!

[QUantumAnenome]

Don't really need tmp.

        tmp=str[i];
        str[i]=str[j];
        str[j]=tmp;

can be rewritten as

        str[i] ^= str[j];
        str[j] ^= str[i];
        str[i] ^= str[j];

[redhead]

^= is Bitwise exclusive OR and assign, which means it will XOR the bit's between the two and assign the value at the same time ie:

bit_a = 10011010
bit_b = 01011010

bit_a ^= bit_b (bit_a = (10011010 ^ 01011010) => bit_a = 11000000 )
bit_b ^= bit_a (bit_b = (01011010 ^ 11000000) => bit_b = 10011010 )
bit_a ^= bit_b (bit_a = (11000000 ^ 10011010) => bit_a = 01011010 )

As you can see, by that logic it will swap the two of them, so if you're dealing with complete bitwise opreations, this is the way..
But on the other hand, will a STORE versus a XOR instruction be faster for the CPU ?

[QUantumAnenome]

No, I believe | is OR, & is AND, and ^ is XOR.

[redhead]

Yeah I just noticed, and corrected the mistake