Как вы отменяете строку на месте в C или c++?

#include <algorithm>
std::reverse(str.begin(), str.end());

Это самый простой способ в C++.

читать Кернигана и Ритчи

#include <string.h>

void reverse(char s[])
{
    int length = strlen(s) ;
    int c, i, j;

    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

изменить строку на месте (визуализация):

Non-evil C, предполагая общий случай, когда строка является null-terminated char время:

#include <stddef.h>
#include <string.h>

/* PRE: str must be either NULL or a pointer to a 
 * (possibly empty) null-terminated string. */
void strrev(char *str) {
  char temp, *end_ptr;

  /* If str is NULL or empty, do nothing */
  if( str == NULL || !(*str) )
    return;

  end_ptr = str + strlen(str) - 1;

  /* Swap the chars */
  while( end_ptr > str ) {
    temp = *str;
    *str = *end_ptr;
    *end_ptr = temp;
    str++;
    end_ptr--;
  }
}

вы используете std::reverse алгоритм из стандартной библиотеки C++.

char input[] = "moc.wolfrevokcats";

int length = strlen(input);
int last_pos = length-1;
for(int i = 0; i < length/2; i++)
{
    char tmp = input[i];
    input[i] = input[last_pos - i];
    input[last_pos - i] = tmp;
}

printf("%s\n", input);

использовать std:: reverse метод STL:

std::reverse(str.begin(), str.end());

вам придется включить библиотеку "алгоритм",#include<algorithm>.

обратите внимание, что красота std:: reverse заключается в том, что он работает с char * строки и std::wstrings так же хорошо, как std::strings

void strrev(char *str)
{
    if (str == NULL)
        return;
    std::reverse(str, str + strlen(str));
}

Если вы ищете реверсирование буферов с нулевым завершением, большинство решений, размещенных здесь, в порядке. Но, как уже отметил Тим Фарли, эти алгоритмы будут работать только в том случае, если допустимо предположить, что строка семантически представляет собой массив байтов (т. е. однобайтовые строки), что является неправильным предположением, я думаю.

возьмите, например, строку " año " (год на испанском языке).

кодовые точки Юникода-0x61, 0xf1, 0x6f.

рассмотрим некоторые из наиболее часто используемых кодировки:

латинских типа 1 / ИСО-8859-1 (однобайтовая кодировка, 1 символ - 1 байт и наоборот):

Оригинал:

0x61, 0xf1, 0x6f, 0x00

реверс:

0x6f, 0xf1, 0x61, 0x00

результат в порядке

UTF-8:

Оригинал:

0x61, 0xc3, 0xb1, 0x6f, 0x00

реверс:

0x6f, 0xb1, 0xc3, 0x61, 0x00

результат-тарабарщина и незаконная последовательность UTF-8

UTF-16 Big Endian:

Оригинал:

0x00, 0x61, 0x00, 0xf1, 0x00, 0x6f, 0x00, 0x00

первый байт будет рассматриваться как нуль-Терминатор. Никакого реверса не будет.

UTF-16 маленький Эндиан:

Оригинал:

0x61, 0x00, 0xf1, 0x00, 0x6f, 0x00, 0x00, 0x00

второй байт будет рассматриваться как нуль-Терминатор. Результатом будет 0x61, 0x00, строка, содержащая символ "a".

в интересах полноты, следует отметить, что существуют представления строк на различных платформах, в которых количество байт на символ зависит в зависимости от характера. Программисты старой школы назвали бы это DBCS (Двухбайтовый набор символов). Современные программисты чаще сталкиваются с этим в UTF-8 (а также UTF-16 и другие). Есть и другие такие кодировки как что ж.

в любой из этих схем кодирования переменной ширины простые алгоритмы, размещенные здесь (зло, не-зло или иначе) не будет работать правильно вообще! Фактически, они могут даже заставить строку стать неразборчивой или даже незаконной строкой в этой схеме кодирования. См.ответ Хуана Пабло Калифано для некоторых хороших примеров.

std:: reverse () потенциально все равно будет работать в этом случае, если реализация вашей платформы стандартной библиотеки C++ (в частности, строковых итераторов) должным образом учитывала это.

#include <cstdio>
#include <cstdlib>
#include <string>

void strrev(char *str)
{
        if( str == NULL )
                return;

        char *end_ptr = &str[strlen(str) - 1];
        char temp;
        while( end_ptr > str )
        {
                temp = *str;
                *str++ = *end_ptr;
                *end_ptr-- = temp;
        }
}

int main(int argc, char *argv[])
{
        char buffer[32];

        strcpy(buffer, "testing");
        strrev(buffer);
        printf("%s\n", buffer);

        strcpy(buffer, "a");
        strrev(buffer);
        printf("%s\n", buffer);

        strcpy(buffer, "abc");
        strrev(buffer);
        printf("%s\n", buffer);

        strcpy(buffer, "");
        strrev(buffer);
        printf("%s\n", buffer);

        strrev(NULL);

        return 0;
}

этот код производит этот выход:

gnitset
a
cba

в случае, если вы используете GLib, он имеет две функции для этого, g_strreverse() и g_utf8_strreverse ()

другой способ C++ (хотя я, вероятно, использовал бы std:: reverse () себя:) как более выразительный и быстрый)

str = std::string(str.rbegin(), str.rend());

путь C (более или менее :) ) и, пожалуйста, будьте осторожны с XOR trick для замены, компиляторы обычно не могут оптимизировать это.

в таком случае это обычно намного медленнее.

char* reverse(char* s)
{
    char* beg = s-1, *end = s, tmp;
    while (*++end);
    while (end-- > ++beg)
    { 
        tmp  = *beg; 
        *beg = *end;  
        *end =  tmp;  
    }
    return s;
}

Мне нравится ответ Евгения K&R. Тем не менее, приятно видеть версию, использующую указатели. В противном случае, это по существу то же самое:

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

char *reverse(char *str) {
    if( str == NULL || !(*str) ) return NULL;
    int i, j = strlen(str)-1;
    char *sallocd;
    sallocd = malloc(sizeof(char) * (j+1));
    for(i=0; j>=0; i++, j--) {
        *(sallocd+i) = *(str+j);
    }
    return sallocd;
}

int main(void) {
    char *s = "a man a plan a canal panama";
    char *sret = reverse(s);
    printf("%s\n", reverse(sret));
    free(sret);
    return 0;
}

рекурсивная функция для реверса строки на месте (без дополнительного буфера, malloc).

короткая, сексуальный код. Плохое, плохое использование стека.

#include <stdio.h>

/* Store the each value and move to next char going down
 * the stack. Assign value to start ptr and increment 
 * when coming back up the stack (return).
 * Neat code, horrible stack usage.
 *
 * val - value of current pointer.
 * s - start pointer
 * n - next char pointer in string.
 */
char *reverse_r(char val, char *s, char *n)
{
    if (*n)
        s = reverse_r(*n, s, n+1);
   *s = val;
   return s+1;
}

/*
 * expect the string to be passed as argv[1]
 */
int main(int argc, char *argv[])
{
    char *aString;

    if (argc < 2)
    {
        printf("Usage: RSIP <string>\n");
        return 0;
    }

    aString = argv[1];
    printf("String to reverse: %s\n", aString );

    reverse_r(*aString, aString, aString+1); 
    printf("Reversed String:   %s\n", aString );

    return 0;
}

поделиться мой код. Как ученик C++, как вариант использования swap (), я смиренно прошу комментариев.

void reverse(char* str) {
    int length = strlen(str);
    char* str_head = str;
    char* str_tail = &str[length-1];
    while (str_head < str_tail) 
        swap(*str_head++, *str_tail--);
}

Если вы используете ATL / MFC CString, просто CString::MakeReverse().

еще:

#include <stdio.h>
#include <strings.h>

int main(int argc, char **argv) {

  char *reverse = argv[argc-1];
  char *left = reverse;
  int length = strlen(reverse);
  char *right = reverse+length-1;
  char temp;

  while(right-left>=1){

    temp=*left;
    *left=*right;
    *right=temp;
    ++left;
    --right;

  }

  printf("%s\n", reverse);

}

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

unsigned char * utf8_reverse(const unsigned char *, int);
void assert_true(bool);

int main(void)
{
    unsigned char str[] = "mañana mañana";
    unsigned char *ret = utf8_reverse(str,  strlen((const char *) str) + 1);

    printf("%s\n", ret);
    assert_true(0 == strncmp((const char *) ret, "anãnam anañam", strlen("anãnam anañam") + 1));

    free(ret);

    return EXIT_SUCCESS;
}

unsigned char * utf8_reverse(const unsigned char *str, int size)
{
    unsigned char *ret = calloc(size, sizeof(unsigned char*));
    int ret_size = 0;
    int pos = size - 2;
    int char_size = 0;

    if (str ==  NULL) {
        fprintf(stderr, "failed to allocate memory.\n");
        exit(EXIT_FAILURE);
    }

    while (pos > -1) {

        if (str[pos] < 0x80) {
            char_size = 1;
        } else if (pos > 0 && str[pos - 1] > 0xC1 && str[pos - 1] < 0xE0) {
            char_size = 2;
        } else if (pos > 1 && str[pos - 2] > 0xDF && str[pos - 2] < 0xF0) {
            char_size = 3;
        } else if (pos > 2 && str[pos - 3] > 0xEF && str[pos - 3] < 0xF5) {
            char_size = 4;
        } else {
            char_size = 1;
        }

        pos -= char_size;
        memcpy(ret + ret_size, str + pos + 1, char_size);
        ret_size += char_size;
    }    

    ret[ret_size] = '';

    return ret;
}

void assert_true(bool boolean)
{
    puts(boolean == true ? "true" : "false");
}

Если вам не нужно хранить его, вы можете уменьшить время, проведенное так:

void showReverse(char s[], int length)
{
    printf("Reversed String without storing is ");
    //could use another variable to test for length, keeping length whole.
    //assumes contiguous memory
    for (; length > 0; length--)
    {
        printf("%c", *(s+ length-1) );
    }
    printf("\n");
}

С C++ лямбда:

 auto reverse = [](std::string& s) -> std::string {
        size_t start = 0, end = s.length() -1;
        char temp;

        while (start < end) {
          temp = s[start];
          s[start++] = s[end];
          s[end--] = temp;
        } 

        return s;
   };

мой ответ будет похож на большинство из них, но, пожалуйста, найдите мой код здесь.

//Method signature to reverse string
string reverseString(string str);

int main(void){
    string str;
    getline(cin, str);
    str =  reverseString(str);
    cout << "The reveresed string is : " << str;
    return 0;
}

/// <summary>
///     Reverses the input string.
/// </summary>
/// <param name="str">
///    This is the input string which needs to be reversed.
/// </param>
/// <return datatype = string>
///     This method would return the reversed string
/// </return datatype>

string reverseString(string str){
    int length = str.size()-1;
    char temp;
    for( int i=0 ;i<(length/2);i++)
    {
        temp = str[i];
        str[i] = str[length-i];
        str[length-i] = temp;
    }
    return str;
}

использовать std::reverse()

reverse(begin(str), end(str));

и это все.

Я думаю,что есть другой способ изменить строку. получите ввод от пользователя и измените его.

void Rev()
{
 char ch;
 cin.get(ch);
 if (ch != '\n')
 {
    Rev();
    cout.put(ch);
 }

}

вот мой взгляд на это в C. сделал это для практики и попытался быть максимально кратким! Вы вводите строку через командную строку, i.e ./имя_программы "введите строку"

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

void reverse(int s,int e,int len,char t,char* arg) {
   for(;s<len/2;t=arg[s],arg[s++]=arg[e],arg[e--]=t);
}

int main(int argc,char* argv[]) {
  int s=0,len=strlen(argv[1]),e=len-1; char t,*arg=argv[1];
  reverse(s,e,len,t,arg);
  for(s=0,e=0;e<=len;arg[e]==' '||arg[e]==''?reverse(s,e-1,e+s,t,arg),s=++e:e++);
  printf("%s\n",arg);
}

но я думаю, что алгоритм подкачки XOR является лучшим...

char str[]= {"I am doing reverse string"};
char* pStr = str;

for(int i = 0; i != ((int)strlen(str)-1)/2; i++)
{
    char b = *(pStr+i);
    *(pStr+i) = *(pStr+strlen(str)-1-i);
    *(pStr+strlen(str)-1-i) = b;
}

#include<stdio.h>
#include<conio.h>

int main()
{
    char *my_string = "THIS_IS_MY_STRING";
    char *rev_my_string = my_string;

    while (*++rev_my_string != '')
        ;

    while (rev_my_string-- != (my_string-1))
    {
        printf("%c", *rev_my_string);
    }

    getchar();
    return 0;
}

это оптимизированный код на языке C для обращения строки... И это просто; просто используйте простой указатель, чтобы выполнить эту работу...

вот самый чистый, безопасный и простой способ изменить строку в C++ (на мой взгляд):

#include <string>

void swap(std::string& str, int index1, int index2) {

    char temp = str[index1];
    str[index1] = str[index2];
    str[index2] = temp;

}

void reverse(std::string& str) {

    for (int i = 0; i < str.size() / 2; i++)
        swap(str, i, str.size() - i - 1);

}

альтернативой является использование std::swap, но мне нравится определять свои собственные функции - это интересное упражнение, и вам не нужно include ничего лишнего.

/**
   I am a boy -> boy a am I
*/
    int main()
    {
        int i, j, n, temp, temp_i, cnt;
        //char *array = "Samsung";
        char array[1000];
        char newarr[strlen(array)];
        printf("Enter The String: \n");
        gets(array);

        for(i = (strlen(array)-1), n = 0, j = 0; i >= 0; i--)
        {
         if( array[i] != ' ')
         {
             n++;
         }
         else
         {
             temp = n;
             temp_i = i;
             for(n = 0; n <= temp; n++)
             {
               //  i = i + 1;
                 newarr[j++] = array[i++];
             }
             i = temp_i;
             n = 0;
         }

         if(i == 0)
         {
             newarr[j++] = ' ';
             temp = n;
             temp_i = i;
             for(n = 0; n <= temp; n++)
             {
               //  i = i + 1;
                 newarr[j++] = array[i++];
             }
             i = temp_i;
             n = 0;
         }


         //newarr[j++] = array[i];
        }
        newarr[j] = '';
        cnt = 0;
        for(j = 0; j <= (strlen(newarr)-1); j++)//This is not required just do some R n D
        {
            newarr[j] = newarr[++cnt];
        }
       //  printf("The first element is %c \n", newarr[1]);
        puts(newarr);
        return 0;
    }