Thread: String reversing and benchmark in C

Im trying to do the C version of something like that in c++:

Code:

#include <string>
#include <bits/stdc++.h>
#include <cstdio>


std::string reverseString (std::string str )
{
  std::string result = "";
  for (int i = str.length()-1 ; i > -1 ; i--)
    {
        result += str[i];
    }
  return result;
}


int main()
{
    std::vector<std::string> Tvec(0xdeaad,"Test_Strings");
    std::cout << "Running for " << Tvec.size() << " test cases." << "\n";


    auto t1 = std::chrono::high_resolution_clock::now();
    for (auto &s : Tvec)
    {
        std::string tested = reverseString(s);
    }
    auto t2 = std::chrono::high_resolution_clock::now();
    auto duration1 = std::chrono::duration_cast<std::chrono::microseconds>(t2-t1).count();
    std::cout << "Duration1 : " << duration1 << "\n";
    
    return 0;
}

I have wrote this so far but it seems all bad and wrong on so many different levels:

Code:

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

char reverseString4(char *str)
{
  size_t strsize = strlen(str);

  char result[strsize];
  for (size_t i = strsize; i > 0; --i) {
    result = str;
  }
  return result;
}

int main(void)
{
  int test_runs = 4096;
  const char *test_word = "deadbeef";
  size_t test_word_len = strlen(test_word);
  char *TEST_ARR[test_runs][test_word_len];
  for (size_t i = 0; i < test_runs; i++) {  //Need to find a way to benchmark the exec time.
    TEST_ARR = test_word;
  }

  return 0;
}

Is there any way I can achieve something like from that first cpp code but in c?

I suggest a function prototype like this:

Code:

char *reverseString4(const char *str);

To implement roughly the same thing as the C++ code, you would:

1. Call strlen to find out the length of str.
2. Call malloc() to allocate storage for the result string, using the length of str + 1.
3. Append to the result string by traversing str in reverse, remembering to null terminate. (Note that your attempt in C is incorrect.)
4. Return the result string.

Note that this means that the caller is responsible for calling free(). Another approach would be to implement two separate functions that are used together: one to reverse the string in-place and another to make a copy of the string, but this would be somewhat different from what you're doing in C++.

Notice the routine strrev_, below, doesn't need to scan for the string length:

Code:

#define swap( a, b ) { typeof(a) t; t = (a); (a) = (b); (b) = t; }

static char *strrev_( char *p, size_t size )
{
  char *str = p;
  char *endp = p + size - 1;

  // scans only half of the buffer.
  while ( endp > p )
  {
    swap( *endp, *p );
    endp--; p++;
  }

  return str;
}

#define strrev( str ) strrev_( (str), strlen( (str) ) )

// 'a' from 'allocated'.
char *strreva( char *str )
{
  char *p;

  p = strdup( str );
  if ( p != NULL )
    return strrev( p );
  return p;
}

char *strrev2( char **dst, char *src )
{
  return *dst = strreva( src );
}

Needless to say this won't work for multibyte charsets like UTF-8.