Trim một chuỗi trong C

Question

ngắn gọn:

tôi sau tương đương với NET của String.Trim trong C bằng cách sử dụng win32 và C api chuẩn (biên soạn với MSVC2008 vì vậy tôi có quyền truy cập vào tất cả các công cụ C++, nếu cần thiết, nhưng Tôi chỉ đang cố gắng cắt một char*).

Cho rằng có strchr, strtok, và tất cả các cách thức của chức năng chuỗi khác, chắc chắn cần phải có một chức năng cắt, hoặc một trong đó có thể được thêm thắt ...

Cảm ơn

Answer 1

Không có chức năng thư viện chuẩn để thực hiện việc này, nhưng không quá khó để cuộn của riêng bạn. Có một số existing question trên SO về việc thực hiện điều này đã được trả lời bằng mã nguồn.

Answer 2

Bạn có thể sử dụng tiêu chuẩn isspace() chức năng trong ctype.h để đạt được điều này. Chỉ cần so sánh các ký tự đầu và cuối của mảng ký tự của bạn cho đến khi cả hai đầu không còn dấu cách.

"không gian" bao gồm:

'' (0x20) không gian (SPC)

'\ t' (0x09) tab ngang (TAB)

'\ n' (0x0a) xuống dòng (LF)

'\ v' (0x0b) tab dọc (VT)

'\ f' (0x0c) ăn (FF)

'\ r' (0x0d) vận chuyển trở lại (CR)

mặc dù không có chức năng mà sẽ làm tất cả các công việc cho bạn, bạn sẽ phải cuộn giải pháp của riêng bạn để so sánh mỗi bên của cho mảng ký tự liên tục cho đến khi không còn khoảng trắng.

Edit:

Vì bạn có quyền truy cập vào C++, Boost có a trim implementation chờ đợi cho bạn để làm cho cuộc sống của bạn dễ dàng hơn nhiều.

Answer 3

Điều dễ nhất cần làm là một vòng lặp đơn giản. Tôi sẽ giả định rằng bạn muốn xâu chuỗi được trả lại tại chỗ.

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 */ 
} 

Điều này cũng loại bỏ khoảng trống được nhúng, nếu String.Trim không cần logic nhiều hơn một chút.

Answer 4

Ngạc nhiên khi thấy những triển khai như vậy. Tôi thường cắt như sau:

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; 
} 

Nó rất nhanh và đáng tin cậy - phục vụ tôi nhiều năm.

Answer 5

Điều này khiến tôi muốn viết của riêng mình - Tôi không thích những cái đã được cung cấp. Dường như với tôi nên có 3 chức năng.

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)); 
} 

Answer 6

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++; 
     } 
    } 
} 

Answer 7

Làm thế nào về vấn đề này ...Nó chỉ yêu cầu một lần lặp qua chuỗi (không sử dụng strlen, mà lặp qua chuỗi). Khi hàm trả về bạn nhận được một con trỏ tới đầu của chuỗi được cắt xén mà không được kết thúc. Chuỗi được cắt không gian từ bên trái (cho đến khi tìm thấy ký tự đầu tiên). Chuỗi cũng được cắt xén của tất cả dấu cách sau ký tự không gian cuối cùng.

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; 
    } 
} 

Answer 8

/* 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; 
} 

Answer 9

#include "stdafx.h" 
#include <string.h> 
#include <ctype.h> 

char* trim(char* input); 


int _tmain(int argc, _TCHAR* argv[]) 
{ 
    char sz1[]=" MQRFH "; 
    char sz2[]=" MQRFH"; 
    char sz3[]=" MQR FH"; 
    char sz4[]="MQRFH "; 
    char sz5[]="MQRFH"; 
    char sz6[]="M"; 
    char sz7[]="M "; 
    char sz8[]=" M"; 
    char sz9[]=""; 
    char sz10[]="  "; 

    printf("sz1:[%s] %d\n",trim(sz1), strlen(sz1)); 
    printf("sz2:[%s] %d\n",trim(sz2), strlen(sz2)); 
    printf("sz3:[%s] %d\n",trim(sz3), strlen(sz3)); 
    printf("sz4:[%s] %d\n",trim(sz4), strlen(sz4)); 
    printf("sz5:[%s] %d\n",trim(sz5), strlen(sz5)); 
    printf("sz6:[%s] %d\n",trim(sz6), strlen(sz6)); 
    printf("sz7:[%s] %d\n",trim(sz7), strlen(sz7)); 
    printf("sz8:[%s] %d\n",trim(sz8), strlen(sz8)); 
    printf("sz9:[%s] %d\n",trim(sz9), strlen(sz9)); 
    printf("sz10:[%s] %d\n",trim(sz10), strlen(sz10)); 

    return 0; 
} 

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

char *rtrim(char *s) 
{  
    char* back; 
    int len = strlen(s); 

    if(len == 0) 
     return(s); 

    back = s + len;  
    while(isspace(*--back));  
    *(back+1) = '\0';  
    return s; 
} 

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

---

Output:

sz1:[MQRFH] 9 
sz2:[MQRFH] 6 
sz3:[MQR FH] 8 
sz4:[MQRFH] 7 
sz5:[MQRFH] 5 
sz6:[M] 1 
sz7:[M] 2 
sz8:[M] 2 
sz9:[] 0 
sz10:[] 8 

Answer 10

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); 
} 

Answer 11

tôi thích nó khi giá trị trả về luôn bằng với đối số. Bằng cách này, nếu mảng chuỗi đã được phân bổ với malloc(), nó có thể an toàn lại là free().

/* Remove leading whitespaces */ 
char *ltrim(char *const s) 
{ 
     size_t len; 
     char *cur; 

     if(s && *s) { 
       len = strlen(s); 
       cur = s; 

       while(*cur && isspace(*cur)) 
         ++cur, --len; 

       if(s != cur) 
         memmove(s, cur, len + 1); 

     } 

     return s; 
} 

/* Remove trailing whitespaces */ 
char *rtrim(char *const s) 
{ 
     size_t len; 
     char *cur; 

     if(s && *s) { 
       len = strlen(s); 
       cur = s + len - 1; 

       while(cur != s && isspace(*cur)) 
         --cur, --len; 

       cur[isspace(*cur) ? 0 : 1] = '\0'; 
     } 

     return s; 
} 

/* Remove leading and trailing whitespaces */ 
char *trim(char *const s) 
{ 
     rtrim(s); // order matters 
     ltrim(s); 

     return s; 
} 

Answer 12

Dưới đây là thực hiện của tôi, hành xử như các chức năng chuỗi tích hợp sẵn trong libc (có nghĩa là, nó hy vọng một c-string, nó sẽ thay đổi nó và trả nó cho người gọi).

Nó cắt không gian hàng đầu & thay đổi các ký tự còn lại ở bên trái, vì nó phân tích chuỗi từ trái sang phải. Sau đó nó đánh dấu một đầu mới của chuỗi và bắt đầu phân tích cú pháp ngược lại, thay thế dấu cách bằng dấu '\ 0' cho đến khi nó tìm thấy ký tự không gian hoặc bắt đầu chuỗi. Tôi tin rằng đó là những lần lặp tối thiểu có thể cho công việc cụ thể này.

// ---------------------------------------------------------------------------- 
// trim leading & trailing spaces from string s (return modified string s) 
// alg: 
// - skip leading spaces, via cp1 
// - shift remaining *cp1's to the left, via cp2 
// - mark a new end of string 
// - replace trailing spaces with '\0', via cp2 
// - return the trimmed s 
// 
char *s_trim(char *s) 
{ 
    char *cp1;        // for parsing the whole s 
    char *cp2;        // for shifting & padding 

    // skip leading spaces, shift remaining chars 
    for (cp1=s; isspace(*cp1); cp1++)  // skip leading spaces, via cp1 
     ; 
    for (cp2=s; *cp1; cp1++, cp2++)   // shift left remaining chars, via cp2 
     *cp2 = *cp1; 
    *cp2-- = 0;        // mark new end of string for s 

    // replace trailing spaces with '\0' 
    while (cp2 > s && isspace(*cp2)) 
     *cp2-- = 0;       // pad with '\0's 

    return s; 
} 

Answer 13

/* Function to remove white spaces on both sides of a string i.e trim */ 

void trim (char *s) 
{ 
    int i; 

    while (isspace (*s)) s++; // skip left side white spaces 
    for (i = strlen (s) - 1; (isspace (s[i])); i--) ; // skip right side white spaces 
    s[i + 1] = '\0'; 
    printf ("%s\n", s); 
} 

Answer 14

void ltrim(char str[PATH_MAX]) 
{ 
     int i = 0, j = 0; 
     char buf[PATH_MAX]; 
     strcpy(buf, str); 
     for(;str[i] == ' ';i++); 

     for(;str[i] != '\0';i++,j++) 
       buf[j] = str[i]; 
     buf[j] = '\0'; 
     strcpy(str, buf); 
} 

Answer 15

Không phải là cách tốt nhất nhưng nó hoạt động

char* Trim(char* str) 
{ 
    int len = strlen(str); 
    char* buff = new char[len]; 
    int i = 0; 
    memset(buff,0,len*sizeof(char)); 
    do{ 
     if(isspace(*str)) continue; 
     buff[i] = *str; ++i; 
    } while(*(++str) != '\0'); 
    return buff; 
}