string reverse

[vxk]

The question is to reverse the string using 2 different functions separately ,
I am not able to get to the logic of the second function :

#include <iostream>
using namespace  std;

//1st function
char* stringreverse(const char* src, char* reversed){
    
    char* temp =  reversed;
    while(*src++);
    src--;
    while(*reversed++ = *--src);
    return temp;
    
    
}

//2nd function
char* stringreverse2(char* src){
    
      //what should i do ?

    
}



int main()
{
    
    char string[] = "abcdefghij";
    char copiedstr[sizeof(string)];
    
    char* src  = string;
    char* reversed  = copiedstr;
    
    cout<<stringreverse(src, reversed)<<endl;
    cout<<stringreverse2(src); // i am not able to define this function

}

[vxk]

any help?

[MiiNiPaa]

Have 2 pointers. One pointing to the beginning of the string, one to the last character. Swap values those pointers are pointing to. Icrement first pointer, decrement second. Repeat until pointers meet.

[SECMoG1T]

You can use the string reverse iterator to copy characters

[anup30]

//Reverse C-string using single argument
char* Reverse(char *src)
{
    char *q = src ;    
    while(*q++) ; // reach to the end of array
    q -=2 ;	//now *q == last element
    
    char *p = new char[sizeof(char) * (q - src + 2)] ; 
    char *r = p ; // keep track of p's current address.

    for( ; q >= src; p++, q--)
        *p =*q;        
    *p = '\0' ;
    
    return r ; //main src unchanged, as *p != src;
}

[vxk]

the above code would leak memory right …cause after new i am not doing delete……what would be a c -style solution to this leak ?

[vxk]

??

[anup30]

sorry! the leak was incautious.
so lets do without dynamic memory >

#include <iostream>
#include <cstring> // strlen()
#include <algorithm> //swap()
using namespace std;

//Reverse C-string using single argument
char* Reverse(char *src) {	
int i=0;
int len = strlen (src)-1;
while(i<len)
   swap (src[i++],src[len--]);    
return src ;
}

int main() {
char ch[]="hello world!";
char *pt = ch;
pt = Reverse (pt);
cout << pt;
return 0;
}

[anup30]

well, code of 8:35am, does not lead to memory leak if you receive it by a pointer, and delete later >

#include <iostream>
//#include <cstring> // strlen()
//#include <algorithm> //swap()
using namespace std;

//Reverse C-string using single argument
char* reverse(char *src)
{   char *q = src ;    
    while(*q++) ; // reach to the end of array
    q -=2 ;	//now *q == last element    
    char *p = new char[sizeof(char) * (q - src + 2)] ; 
    char *r = p ; // keep track of p's current address.
    for( ; q >= src; p++, q--)
        *p =*q;        
    *p = '\0' ;   
    //cant delete[] p; r will be lost
    return r ; //main src unchanged, as *p != src;
}

int main() {
char ch[]="hello world!";
char *pt = ch;
pt = reverse (pt);
cout << pt;
delete[] pt; // here
return 0;
}

[anup30]

its better Reverse function of 6:01pm be void, as it changes the caller:

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

void Reverse(char *src) {
int i=0;
int len = strlen (src)-1;
while(i<len)
   swap (src[i++],src[len--]);    
return;
}

int main() {
char ch[]="hello world!";
char *pt = ch;
Reverse (pt); // ch[] changes
cout << ch;
return 0;
}

[MiiNiPaa]

Proper C logic would be to reverse string in-place (modifying original) and return it. That is how C standard library works. Almost no standard functions allocate theitr own memory, they work only with buffers provided by user.

Additionally function signature suggest that passed string would be modified.

[anup30]

std::string is much easier..

#include <iostream>
#include <algorithm> // reverse();

int main()
{  	
   string s = "Hello world!";
   std::reverse( s.begin(), s.end() );
   std::cout << s;  
   return 0;
}

[MiiNiPaa]

std::string is much easier..

You forgot to #include <string>

Also:

#include <iostream>
#include <algorithm> // reverse();

int main()
{  	
   char s[] = "Hello world!";
   std::reverse( std::begin(s), std::end(s) - 1);
   std::cout << s;  
}

[MiiNiPaa]

as well as your code runs without <cstring>

My code does not use anything declared in cstring header. Your code uses type declared in string header.

my code runs

Not an argument. It is just an implementation detail that iostream happens to include string. Some other compiler might not do that. Standard says that you need to explicitely include all headers which contain entities you are using. (My code is not perfect either: i need to include iterator)

http://stackoverflow.com/questions/9539650/why-does-omission-of-include-string-only-sometimes-cause-compilation-failur

[anup30]

its not serious error! just a matter of forgetting. if compile, anyone can get it.
however, my main mistake was to forget "using namespace std;"
the code below runs both in devcpp and http://cpp.sh/

#include <iostream>
#include <algorithm> // reverse();
//#include <string>
using namespace std;

int main()
{  	
   string s = "Hello world!";
   reverse( s.begin(), s.end() );
   cout << s;  
   return 0;
}

but the following does not.

#include <iostream>
#include <algorithm> // reverse();
#include <string>
//using namespace std;

int main()
{  	
   string s = "Hello world!";
   reverse( s.begin(), s.end() );
   cout << s;  
   return 0;
}

these doesn't matter at all, because all focus would be in line 7, both of mine and yours ;)

[giblit]

@annup30, you should use std:: to scope to the things in the namespace. Otherwise it makes the namespaces completely useless. They are meant to avoid naming conflicts. When you throw everything in the global namespace it does the opposite. Anyways..If you are going to use std::strings why not do something like

std::string str1 = "Hello, world!";
std::string str2(str1.rbegin(), str1.rend());

or

std::string str = "Hello, world!";
str = std::string(str.rbegin(), str.rend());

Though, these won't even help the OP since he seems to be doing it with dynamic c-strings.

[anup30]

Otherwise it makes the namespaces completely useless

i was watching code of some best programmers of the world - the Google Code Jam finalist's solutions to extreme problems - nearly two third of the solutions were in C++. everyone used "using namespace std;"

problems: https://code.google.com/codejam/contest/7214486/dashboard

solutions: https://code.google.com/codejam/contest/7214486/scoreboard#vf=1
sol/statistics: http://www.go-hero.net/jam/13/solutions

[MiiNiPaa]

Code Jam

Not the best reference. He (a) needs to write code extremely fast (which, mind you, is very rarely the case in real life), (b) a good programmer and know exactly rules of name lookup and which names are contained in std namespace. Can you name at least 20 names which are not commonly used but exist in std namespace?

[anup30]

commonly used

is a vague term. such as all contestants included <vector> (//std::vector)
but if you use vector in these beginners forum, OPs will normally say that they don't know vector.
so, for teaching you have to mention "std::x" explicitly.
but for elements you already know, if written in every instance - its boring. without it i have clearer visualization of code, and bug could be found quicker.
not to mention, i also like smaller and easier code.
in terms of efficiency, does your program run faster with every instance "std::x" ?

[MiiNiPaa]

in terms of efficiency, does your program run faster with every instance "std::x" ?

No, it should not, it is compile time thing.

Find the potential problems and try to guess why this wasn't a problem earlier:
1)

using namespace boost;
using namespace std;

2)

#include <geometryV1.6.h>
using namespace std;

3)

using namespace geom;
using namespace std;

http://stackoverflow.com/questions/2712076/how-to-use-an-iterator
http://stackoverflow.com/questions/1452721/why-is-using-namespace-std-considered-bad-practice