Обрежьте строку в C [дубликат]

Самой легкой вещью сделать является простой цикл. Я собираюсь предположить, что Вы хотите обрезанную строку, возвращенную на месте.

char *
strTrim(char * s){
    int ix, jx;
    int len ;
    char * buf 
    len = strlen(s);  /* possibly should use strnlen */
    buf = (char *) malloc(strlen(s)+1);

    for(ix=0, jx=0; ix < len; ix++){
       if(!isspace(s[ix]))
          buf[jx++] = s[ix];

    buf[jx] = '\0';
    strncpy(s, buf, jx);  /* always looks as far as the null, but who cares? */
    free(buf);            /* no good leak goes unpunished */
    return s;             /* modifies s in place *and* returns it for swank */
 }

Это избавляется от встроенных пробелов также, если Строка. Обрезка не делает тогда, требуется немного больше логики.

static inline void ut_trim(char * str) {
   char * start = str;
   char * end = start + strlen(str);

   while (--end >= start) {   /* trim right */
      if (!isspace(*end))
         break;
   }
   *(++end) = '\0';

   while (isspace(*start))    /* trim left */
      start++;

   if (start != str)          /* there is a string */
      memmove(str, start, end - start + 1);
}

Удивленный видеть такие реализации. Я обычно обрезаю как это:

char *trim(char *s) {
    char *ptr;
    if (!s)
        return NULL;   // handle NULL string
    if (!*s)
        return s;      // handle empty string
    for (ptr = s + strlen(s) - 1; (ptr >= s) && isspace(*ptr); --ptr);
    ptr[1] = '\0';
    return s;
}

Это быстро и надежно - служит мне много лет.

Можно использовать стандарт isspace () функция в ctype.h для достижения этого. Просто сравните начальные и конечные символы своего символьного массива, пока оба конца больше не будут иметь пробелы.

"пробелы" включают:

' '(0x20) пространство (SPC)

т' (0x09) горизонтальная вкладка (ВКЛАДКА)

'\n' (0x0a) новая строка (LF)

'\v' (0x0b) вертикальная вкладка (VT)

'\f' (0x0c) канал (FF)

'\r' (0x0d) возврат каретки (CR)

, хотя нет никакой функции, которая сделает всю работу для Вас, Вы будете иметь к решению для самокрутки сравнивать каждую сторону данного символьного массива неоднократно, пока никакие пробелы не останутся.

Редактирование:

, Так как у Вас есть доступ к C++, Повышение имеет реализация для обрезки ожидание Вас для создания жизни намного легче.

Это заставило меня написать свой собственный - мне не понравились что было предоставлено. Мне кажется, должно быть 3 функции.

char *ltrim(char *s)
{
    while(isspace(*s)) s++;
    return s;
}

char *rtrim(char *s)
{
    char* back = s + strlen(s);
    while(isspace(*--back));
    *(back+1) = '\0';
    return s;
}

char *trim(char *s)
{
    return rtrim(ltrim(s)); 
}

void inPlaceStrTrim(char* str) {
    int k = 0;
    int i = 0;
    for (i=0; str[i] != '\0';) {
        if (isspace(str[i])) {
            // we have got a space...
            k = i;
            for (int j=i; j<strlen(str)-1; j++) {
                str[j] = str[j+1];
            }
            str[strlen(str)-1] = '\0';
            i = k; // start the loop again where we ended..
        } else {
            i++;
        }
    }
}

Как насчет этого... Она требует только одной итерации по строке (не использует strlen, которая итерирует строку). Когда функция возвращается, вы получаете указатель на начало обрезанной строки, которая имеет нулевое окончание. Строка обрезается от пробелов слева (пока не будет найден первый символ). Строка также обрезается от всех пробелов после последнего непробельного символа.

char* trim(char* input) {
    char* start = input;
    while (isSpace(*start)) { //trim left
        start++;
    }

    char* ptr = start;
    char* end = start;
    while (*ptr++ != '\0') { //trim right
        if (!isSpace(*ptr)) { //only move end pointer if char isn't a space
            end = ptr;
        }
    }

    *end = '\0'; //terminate the trimmed string with a null
    return start;
}

bool isSpace(char c) {
    switch (c) {
        case ' ':
        case '\n':
        case '\t':
        case '\f':
        case '\r':
            return true;
            break;
        default:
            return false;
            break;
    }
}

/* iMode 0:ALL, 1:Left, 2:Right*/
char* Trim(char* szStr,const char ch, int iMode)
{
    if (szStr == NULL)
        return NULL;
    char szTmp[1024*10] = { 0x00 };
    strcpy(szTmp, szStr);
    int iLen = strlen(szTmp);
    char* pStart = szTmp;
    char* pEnd = szTmp+iLen;
    int i;
    for(i = 0;i < iLen;i++){
        if (szTmp[i] == ch && pStart == szTmp+i && iMode != 2)
            ++pStart;
        if (szTmp[iLen-i-1] == ch && pEnd == szTmp+iLen-i && iMode != 1)
            *(--pEnd) = '\0';
    }
    strcpy(szStr, pStart);
    return szStr;
}