標準的な方法で先頭/末尾の空白をトリミングするにはどうすればよいですか?

https://stackoverflow.com/questions/122616

02-07-2019
|

質問

C の文字列から先頭と末尾の空白を削除するクリーンな、できれば標準的な方法はありますか?私自身も考えてみますが、これはよくある問題であり、同様に一般的な解決策があると思います。

解決

文字列を変更できる場合:

// Note: This function returns a pointer to a substring of the original string.
// If the given string was allocated dynamically, the caller must not overwrite
// that pointer with the returned value, since the original pointer must be
// deallocated using the same allocator with which it was allocated.  The return
// value must NOT be deallocated using free() etc.
char *trimwhitespace(char *str)
{
  char *end;

  // Trim leading space
  while(isspace((unsigned char)*str)) str++;

  if(*str == 0)  // All spaces?
    return str;

  // Trim trailing space
  end = str + strlen(str) - 1;
  while(end > str && isspace((unsigned char)*end)) end--;

  // Write new null terminator character
  end[1] = '\0';

  return str;
}

文字列を変更できない場合は、基本的に同じ方法を使用できます。

// Stores the trimmed input string into the given output buffer, which must be
// large enough to store the result.  If it is too small, the output is
// truncated.
size_t trimwhitespace(char *out, size_t len, const char *str)
{
  if(len == 0)
    return 0;

  const char *end;
  size_t out_size;

  // Trim leading space
  while(isspace((unsigned char)*str)) str++;

  if(*str == 0)  // All spaces?
  {
    *out = 0;
    return 1;
  }

  // Trim trailing space
  end = str + strlen(str) - 1;
  while(end > str && isspace((unsigned char)*end)) end--;
  end++;

  // Set output size to minimum of trimmed string length and buffer size minus 1
  out_size = (end - str) < len-1 ? (end - str) : len-1;

  // Copy trimmed string and add null terminator
  memcpy(out, str, out_size);
  out[out_size] = 0;

  return out_size;
}

他のヒント

これは、文字列をバッファの最初の位置にシフトするものです。文字列を動的に割り当てた場合でも、trim() が返す同じポインタ上で文字列を解放できるように、この動作が必要な場合があります。

char *trim(char *str)
{
    size_t len = 0;
    char *frontp = str;
    char *endp = NULL;

    if( str == NULL ) { return NULL; }
    if( str[0] == '\0' ) { return str; }

    len = strlen(str);
    endp = str + len;

    /* Move the front and back pointers to address the first non-whitespace
     * characters from each end.
     */
    while( isspace((unsigned char) *frontp) ) { ++frontp; }
    if( endp != frontp )
    {
        while( isspace((unsigned char) *(--endp)) && endp != frontp ) {}
    }

    if( str + len - 1 != endp )
            *(endp + 1) = '\0';
    else if( frontp != str &&  endp == frontp )
            *str = '\0';

    /* Shift the string so that it starts at str so that if it's dynamically
     * allocated, we can still free it on the returned pointer.  Note the reuse
     * of endp to mean the front of the string buffer now.
     */
    endp = str;
    if( frontp != str )
    {
            while( *frontp ) { *endp++ = *frontp++; }
            *endp = '\0';
    }


    return str;
}

正しさのテスト:

int main(int argc, char *argv[])
{
    char *sample_strings[] =
    {
            "nothing to trim",
            "    trim the front",
            "trim the back     ",
            " trim one char front and back ",
            " trim one char front",
            "trim one char back ",
            "                   ",
            " ",
            "a",
            "",
            NULL
    };
    char test_buffer[64];
    int index;

    for( index = 0; sample_strings[index] != NULL; ++index )
    {
            strcpy( test_buffer, sample_strings[index] );
            printf("[%s] -> [%s]\n", sample_strings[index],
                                     trim(test_buffer));
    }

    /* The test prints the following:
    [nothing to trim] -> [nothing to trim]
    [    trim the front] -> [trim the front]
    [trim the back     ] -> [trim the back]
    [ trim one char front and back ] -> [trim one char front and back]
    [ trim one char front] -> [trim one char front]
    [trim one char back ] -> [trim one char back]
    [                   ] -> []
    [ ] -> []
    [a] -> [a]
    [] -> []
    */

    return 0;
}

ソースファイルはtrim.cでした。「cc トリム.c -o トリム」でコンパイルされます。

私の解決策。文字列は変更可能である必要があります。他のいくつかのソリューションに比べて、非スペース部分を先頭に移動するため、後で free() する必要がある場合に古いポインターを使い続けることができるという利点があります。

void trim(char * s) {
    char * p = s;
    int l = strlen(p);

    while(isspace(p[l - 1])) p[--l] = 0;
    while(* p && isspace(* p)) ++p, --l;

    memmove(s, p, l + 1);
}

このバージョンでは、文字列を編集するのではなく、strndup() を使用して文字列のコピーを作成します。strndup() には _GNU_SOURCE が必要なので、malloc() と strncpy() を使用して独自の strndup() を作成する必要があるかもしれません。

char * trim(char * s) {
    int l = strlen(s);

    while(isspace(s[l - 1])) --l;
    while(* s && isspace(* s)) ++s, --l;

    return strndup(s, l);
}

これは、左、右、両方、すべて、定位置および個別にトリミングし、指定された文字のセット (またはデフォルトでは空白) をトリミングするための私の C mini ライブラリです。

strlib.h の内容:

#ifndef STRLIB_H_
#define STRLIB_H_ 1
enum strtrim_mode_t {
    STRLIB_MODE_ALL       = 0, 
    STRLIB_MODE_RIGHT     = 0x01, 
    STRLIB_MODE_LEFT      = 0x02, 
    STRLIB_MODE_BOTH      = 0x03
};

char *strcpytrim(char *d, // destination
                 char *s, // source
                 int mode,
                 char *delim
                 );

char *strtriml(char *d, char *s);
char *strtrimr(char *d, char *s);
char *strtrim(char *d, char *s); 
char *strkill(char *d, char *s);

char *triml(char *s);
char *trimr(char *s);
char *trim(char *s);
char *kill(char *s);
#endif

strlib.c の内容:

#include <strlib.h>

char *strcpytrim(char *d, // destination
                 char *s, // source
                 int mode,
                 char *delim
                 ) {
    char *o = d; // save orig
    char *e = 0; // end space ptr.
    char dtab[256] = {0};
    if (!s || !d) return 0;

    if (!delim) delim = " \t\n\f";
    while (*delim) 
        dtab[*delim++] = 1;

    while ( (*d = *s++) != 0 ) { 
        if (!dtab[0xFF & (unsigned int)*d]) { // Not a match char
            e = 0;       // Reset end pointer
        } else {
            if (!e) e = d;  // Found first match.

            if ( mode == STRLIB_MODE_ALL || ((mode != STRLIB_MODE_RIGHT) && (d == o)) ) 
                continue;
        }
        d++;
    }
    if (mode != STRLIB_MODE_LEFT && e) { // for everything but trim_left, delete trailing matches.
        *e = 0;
    }
    return o;
}

// perhaps these could be inlined in strlib.h
char *strtriml(char *d, char *s) { return strcpytrim(d, s, STRLIB_MODE_LEFT, 0); }
char *strtrimr(char *d, char *s) { return strcpytrim(d, s, STRLIB_MODE_RIGHT, 0); }
char *strtrim(char *d, char *s) { return strcpytrim(d, s, STRLIB_MODE_BOTH, 0); }
char *strkill(char *d, char *s) { return strcpytrim(d, s, STRLIB_MODE_ALL, 0); }

char *triml(char *s) { return strcpytrim(s, s, STRLIB_MODE_LEFT, 0); }
char *trimr(char *s) { return strcpytrim(s, s, STRLIB_MODE_RIGHT, 0); }
char *trim(char *s) { return strcpytrim(s, s, STRLIB_MODE_BOTH, 0); }
char *kill(char *s) { return strcpytrim(s, s, STRLIB_MODE_ALL, 0); }

1 つのメインルーチンがすべてを実行します。場合は、その場でトリミングされます 送信元 == 夏時間, それ以外の場合、それはのように機能します strcpy ルーチン。文字列で指定された文字のセットをトリミングします。 デリム, 、null の場合は空白。左、右、両方、すべてをトリミングします (tr のように)。これにはそれほど多くはなく、文字列を 1 回だけ反復処理します。一部の人々は、trim right が左側から始まることに不満を言うかもしれませんが、とにかく左側から始まる strlen は必要ありません。(いずれにしても、適切にトリムするには文字列の最後まで到達する必要があるので、作業を進めながら行うほうがよいでしょう。) パイプライン処理やキャッシュサイズなどについては議論があるかもしれませんが、それは誰にもわかりません。。このソリューションは左から右に動作し、反復は 1 回だけであるため、ストリームでも動作するように拡張できます。制限事項:しますない取り組む ユニコード 文字列。

これは、シンプルでありながら正確なインプレーストリム関数への私の試みです。

void trim(char *str)
{
    int i;
    int begin = 0;
    int end = strlen(str) - 1;

    while (isspace((unsigned char) str[begin]))
        begin++;

    while ((end >= begin) && isspace((unsigned char) str[end]))
        end--;

    // Shift all characters back to the start of the string array.
    for (i = begin; i <= end; i++)
        str[i - begin] = str[i];

    str[i - begin] = '\0'; // Null terminate string.
}

トリムパーティーに遅刻

特徴：
1.他の多くの回答と同様に、最初をすぐにトリミングしてください。
2.最後まで行った後、ループごとに 1 つのテストのみを使用して右側をトリミングします。@jfm3 と似ていますが、すべて空白文字列に対して機能します)
3.次の場合に未定義の動作を避けるため char 署名されたものです char, 、キャスト *s に unsigned char.

文字の処理 「すべての場合において、議論は int, 、その値は次のように表すことができます。 unsigned char またはマクロの値と等しいものとする EOF. 。引数に他の値がある場合、動作は未定義です。」 C11 §7.4 1

#include <ctype.h>

// Return a pointer to the trimmed string
char *string_trim_inplace(char *s) {
  while (isspace((unsigned char) *s)) s++;
  if (*s) {
    char *p = s;
    while (*p) p++;
    while (isspace((unsigned char) *(--p)));
    p[1] = '\0';
  }

  // If desire to shift the trimmed string

  return s;
}

@chqrlie 上記のコメントは、トリミングされた文字列をシフトしません。そうするために....

// Return a pointer to the (shifted) trimmed string
char *string_trim_inplace(char *s) {
  char *original = s;
  size_t len = 0;

  while (isspace((unsigned char) *s)) {
    s++;
  } 
  if (*s) {
    char *p = s;
    while (*p) p++;
    while (isspace((unsigned char) *(--p)));
    p[1] = '\0';
    len = (size_t) (p - s);
  }

  return (s == original) ? s : memove(original, s, len + 1);
}

これは @adam-rosenfields のインプレース変更ルーチンに似た解決策ですが、不必要に strlen() に頼ることはありません。@jkramer と同様に、文字列はバッファ内で左寄せされるため、同じポインタを解放できます。memmove を使用しないため、大きな文字列には最適ではありません。@jfm3 が言及した ++/-- 演算子が含まれます。 FCTX-ベースの単体テストが含まれています。

#include <ctype.h>

void trim(char * const a)
{
    char *p = a, *q = a;
    while (isspace(*q))            ++q;
    while (*q)                     *p++ = *q++;
    *p = '\0';
    while (p > a && isspace(*--p)) *p = '\0';
}

/* See http://fctx.wildbearsoftware.com/ */
#include "fct.h"

FCT_BGN()
{
    FCT_QTEST_BGN(trim)
    {
        { char s[] = "";      trim(s); fct_chk_eq_str("",    s); } // Trivial
        { char s[] = "   ";   trim(s); fct_chk_eq_str("",    s); } // Trivial
        { char s[] = "\t";    trim(s); fct_chk_eq_str("",    s); } // Trivial
        { char s[] = "a";     trim(s); fct_chk_eq_str("a",   s); } // NOP
        { char s[] = "abc";   trim(s); fct_chk_eq_str("abc", s); } // NOP
        { char s[] = "  a";   trim(s); fct_chk_eq_str("a",   s); } // Leading
        { char s[] = "  a c"; trim(s); fct_chk_eq_str("a c", s); } // Leading
        { char s[] = "a  ";   trim(s); fct_chk_eq_str("a",   s); } // Trailing
        { char s[] = "a c  "; trim(s); fct_chk_eq_str("a c", s); } // Trailing
        { char s[] = " a ";   trim(s); fct_chk_eq_str("a",   s); } // Both
        { char s[] = " a c "; trim(s); fct_chk_eq_str("a c", s); } // Both

        // Villemoes pointed out an edge case that corrupted memory.  Thank you.
        // http://stackoverflow.com/questions/122616/#comment23332594_4505533
        {
          char s[] = "a     ";       // Buffer with whitespace before s + 2
          trim(s + 2);               // Trim "    " containing only whitespace
          fct_chk_eq_str("", s + 2); // Ensure correct result from the trim
          fct_chk_eq_str("a ", s);   // Ensure preceding buffer not mutated
        }

        // doukremt suggested I investigate this test case but
        // did not indicate the specific behavior that was objectionable.
        // http://stackoverflow.com/posts/comments/33571430
        {
          char s[] = "         foobar";  // Shifted across whitespace
          trim(s);                       // Trim
          fct_chk_eq_str("foobar", s);   // Leading string is correct

          // Here is what the algorithm produces:
          char r[16] = { 'f', 'o', 'o', 'b', 'a', 'r', '\0', ' ',                     
                         ' ', 'f', 'o', 'o', 'b', 'a', 'r', '\0'};
          fct_chk_eq_int(0, memcmp(s, r, sizeof(s)));
        }
    }
    FCT_QTEST_END();
}
FCT_END();

もう 1 つは、実際の仕事を行う 1 行です。

#include <stdio.h>

int main()
{
   const char *target = "   haha   ";
   char buf[256];
   sscanf(target, "%s", buf); // Trimming on both sides occurs here
   printf("<%s>\n", buf);
}

これらの回答のほとんどは、次の 1 つ以上を行っているため、気に入りませんでした。

元のポインタの文字列内で別のポインタを返しました (同じものへの 2 つの異なるポインタをやりくりするのはちょっと面倒です)。
などのものを無償で使用した strlen() 文字列全体を事前に反復します。
移植性のない OS 固有の lib 関数を使用しました。
バックスキャン済み。
との比較に使用 ' ' の代わりに isspace() TAB / CR / LF が保持されるようにします。
大きな静的バッファによるメモリの無駄。
次のような高コストの機能による無駄なサイクル sscanf/sprintf.

私のバージョンは次のとおりです。

void fnStrTrimInPlace(char *szWrite) {

    const char *szWriteOrig = szWrite;
    char       *szLastSpace = szWrite, *szRead = szWrite;
    int        bNotSpace;

    // SHIFT STRING, STARTING AT FIRST NON-SPACE CHAR, LEFTMOST
    while( *szRead != '\0' ) {

        bNotSpace = !isspace((unsigned char)(*szRead));

        if( (szWrite != szWriteOrig) || bNotSpace ) {

            *szWrite = *szRead;
            szWrite++;

            // TRACK POINTER TO LAST NON-SPACE
            if( bNotSpace )
                szLastSpace = szWrite;
        }

        szRead++;
    }

    // TERMINATE AFTER LAST NON-SPACE (OR BEGINNING IF THERE WAS NO NON-SPACE)
    *szLastSpace = '\0';
}

パーティーにとても遅れてしまいました...

バックトラッキングのないシングルパス順方向スキャンソリューション。ソース文字列内のすべての文字が正確にテストされます一度 2回。(したがって、特にソース文字列の末尾に多くのスペースがある場合は、ここで説明する他のほとんどのソリューションよりも高速になるはずです。)

これには 2 つの解決策が含まれます。1 つはソース文字列をコピーして別の宛先文字列にトリミングする方法、もう 1 つはソース文字列をその場でトリミングする方法です。どちらの関数も同じコードを使用します。

(変更可能な) 文字列はその場に移動されるため、その文字列への元のポインタは変更されません。

#include <stddef.h>
#include <ctype.h>

char * trim2(char *d, const char *s)
{
    // Sanity checks
    if (s == NULL  ||  d == NULL)
        return NULL;

    // Skip leading spaces        
    const unsigned char * p = (const unsigned char *)s;
    while (isspace(*p))
        p++;

    // Copy the string
    unsigned char * dst = (unsigned char *)d;   // d and s can be the same
    unsigned char * end = dst;
    while (*p != '\0')
    {
        if (!isspace(*dst++ = *p++))
            end = dst;
    }

    // Truncate trailing spaces
    *end = '\0';
    return d;
}

char * trim(char *s)
{
    return trim2(s, s);
}

何を「無痛」と考えるのかわかりません。

C弦はかなり痛いです。最初の非空白文字の位置は簡単に見つけることができます。

while (isspace(* p)) p++;

空白以外の最後の文字の位置は、次の 2 つの同様の簡単な操作で見つけることができます。

while (* q) q++;
do { q--; } while (isspace(* q));

（私はあなたを使用する苦痛を省きました） * そして ++ オペレーターも同時に操作します。)

今の問題は、これをどうするかということです。現在のデータ型は実際には大きく堅牢な抽象ではありません String これは考えるのは簡単ですが、実際にはストレージバイトの配列以上のものではありません。堅牢なデータ型が欠如しているため、PHperytonby の関数と同じことを行う関数を書くことは不可能です。 chomp 関数。C のこのような関数は何を返すでしょうか?

使う文字列ライブラリ, 、例えば：

Ustr *s1 = USTR1(\7, " 12345 ");

ustr_sc_trim_cstr(&s1, " ");
assert(ustr_cmp_cstr_eq(s1, "12345"));

...あなたが言うように、これは「一般的な」問題です、はい、#include などを含める必要があり、libc には含まれていませんが、ランダムなポインターと size_t を格納する独自のハックジョブを発明しないでください。その方法では、バッファオーバーフロー。

#include "stdafx.h"
#include "malloc.h"
#include "string.h"

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

  char *ptr = (char*)malloc(sizeof(char)*30);
  strcpy(ptr,"            Hel  lo    wo           rl   d G    eo rocks!!!    by shahil    sucks b i          g       tim           e");

  int i = 0, j = 0;

  while(ptr[j]!='\0')
  {

      if(ptr[j] == ' ' )
      {
          j++;
          ptr[i] = ptr[j];
      }
      else
      {
          i++;
          j++;
          ptr[i] = ptr[j];
      }
  }


  printf("\noutput-%s\n",ptr);
        return 0;
}

とても役に立ちました。この投稿が利用できてよかったと伝え、例を使って何ができるかを示したかったのです。より大きな文字列をトークン化し、部分文字列を取得して最後の文字列を見つける必要がありました。そのため、 fgets() 呼び出しから改行を削除し、そのトークンの先頭から空白も削除できました。静的文字列と簡単に比較できます。上記の投稿の最初の例でそこにたどり着くことができました。ありがとうございます。コードサンプルの使用方法と得られた出力は次のとおりです。

int _tmain(int argc, _TCHAR* argv[])
{
   FILE * fp;   // test file
   char currDBSStatstr[100] = {"/0"};
   char *beg;
   char *end;
   char *str1;
   char str[] = "Initializing DBS Configuration";
   fp = fopen("file2-1.txt","r");
   if (fp != NULL)
   {
      printf("File exists.\n");
      fgets(currDBSStatstr, sizeof(currDBSStatstr), fp);
   }
   else
   {
      printf("Error.\n");
      exit(2);
   }  
   //print string
   printf("String: %s\n", currDBSStatstr);
   //extract first string
   str1 = strtok(currDBSStatstr, ":-");
   //print first token
   printf("%s\n", str1);
   //get more tokens in sequence
   while(1)
   {
      //extract more tokens in sequence
      str1 = strtok(NULL, ":-");
      //check to see if done
      if (str1 == NULL)
      {
         printf("Tokenizing Done.\n");
         exit(0);
      }
      //print string after tokenizing Done
      printf("%s\n", str1);
      end = str1 + strlen(str1) - 1;
      while((end > str1) && (*end == '\n'))
      {
         end--;
         *(end+1) = 0;
         beg = str1;
         while(isspace(*str1))
            str1++;
      }
      printf("%s\n", str1);
      if (strcmp(str, str1) == 0)
         printf("Strings are equal.\n");
   }
   return 0;

}

出力

ファイルが存在しています。

弦：DBS 状態:DBS の起動 - DBS 構成の初期化

DBS 状態

DBSの起動

DBSの起動

DBS 構成の初期化

DBS 構成の初期化

文字列は等しいです。

トークン化が完了しました。

使用している場合 glib, 、その後、使用できます g_strstrip

これをさらに拡大し続けるために、変更可能な文字列を含むオプションがもう 1 つあります。

void trimString(char *string)
{
    size_t i = 0, j = strlen(string);
    while (j > 0 && isspace((unsigned char)string[j - 1])) string[--j] = '\0';
    while (isspace((unsigned char)string[i])) i++;
    if (i > 0) memmove(string, string + i, j - i + 1);
}

多くの答えがあることは承知していますが、私の解決策が十分であるかどうかを確認するために、ここに私の答えを投稿します。

// Trims leading whitespace chars in left `str`, then copy at almost `n - 1` chars
// into the `out` buffer in which copying might stop when the first '\0' occurs, 
// and finally append '\0' to the position of the last non-trailing whitespace char.
// Reture the length the trimed string which '\0' is not count in like strlen().
size_t trim(char *out, size_t n, const char *str)
{
    // do nothing
    if(n == 0) return 0;    

    // ptr stop at the first non-leading space char
    while(isspace(*str)) str++;    

    if(*str == '\0') {
        out[0] = '\0';
        return 0;
    }    

    size_t i = 0;    

    // copy char to out until '\0' or i == n - 1
    for(i = 0; i < n - 1 && *str != '\0'; i++){
        out[i] = *str++;
    }    

    // deal with the trailing space
    while(isspace(out[--i]));    

    out[++i] = '\0';
    return i;
}

文字列内の先頭のスペースをスキップする最も簡単な方法は、私見ですが、

#include <stdio.h>

int main()
{
char *foo="     teststring      ";
char *bar;
sscanf(foo,"%s",bar);
printf("String is >%s<\n",bar);
    return 0;
}

OK、これが質問に対する私の見解です。文字列をその場で変更するのが最も簡潔な解決策だと思います(free 動作します）、UBを回避します。小さな文字列の場合、おそらく memmove を使用する解決策よりも高速です。

void stripWS_LT(char *str)
{
    char *a = str, *b = str;
    while (isspace((unsigned char)*a)) a++;
    while (*b = *a++)  b++;
    while (b > str && isspace((unsigned char)*--b)) *b = 0;
}

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

char *trim_space(char *in)
{
    char *out = NULL;
    int len;
    if (in) {
        len = strlen(in);
        while(len && isspace(in[len - 1])) --len;
        while(len && *in && isspace(*in)) ++in, --len;
        if (len) {
            out = strndup(in, len);
        }
    }
    return out;
}

isspace すべての空白をトリミングするのに役立ちます。

最初のループを実行して、最後のバイトからスペース文字をチェックし、長さの変数を減らします。
2 番目のループを実行して、最初のバイトからスペース文字をチェックし、長さ変数を減らして char ポインタを増分します。
最後に、長さ変数が 0 より大きい場合は、次を使用します。 strndup スペースを除外して新しい文字列バッファを作成します。

個人的には、自分で巻くと思います。strtok を使用することもできますが、その際には (特に先頭の文字を削除する場合)、どのメモリが何であるかを理解するように注意する必要があります。

末尾のスペースを削除するのは簡単で、最後から逆算して最後のスペースの先頭に 0 を追加するだけなので、非常に安全です。先頭のスペースを削除するということは、内容を移動することを意味します。これを適切な位置で実行したい場合は (おそらく賢明です)、先頭のスペースがなくなるまですべてを 1 文字ずつ戻し続けるだけです。または、より効率的にするには、最初の非スペース文字のインデックスを見つけて、その番号だけすべてを戻すこともできます。または、最初の非スペース文字へのポインターを使用することもできます (ただし、その場合は strtok の場合と同じように注意する必要があります)。

試合には少し遅れましたが、ルーティンを戦いに投入します。おそらくそれらは最も絶対的に効率的ではありませんが、私はそれらが正しく、シンプルであると信じています（ rtrim() 複雑さの限界を押し上げる):

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

/*
    Public domain implementations of in-place string trim functions

    Michael Burr
    michael.burr@nth-element.com
    2010
*/

char* ltrim(char* s) 
{
    char* newstart = s;

    while (isspace( *newstart)) {
        ++newstart;
    }

    // newstart points to first non-whitespace char (which might be '\0')
    memmove( s, newstart, strlen( newstart) + 1); // don't forget to move the '\0' terminator

    return s;
}


char* rtrim( char* s)
{
    char* end = s + strlen( s);

    // find the last non-whitespace character
    while ((end != s) && isspace( *(end-1))) {
            --end;
    }

    // at this point either (end == s) and s is either empty or all whitespace
    //      so it needs to be made empty, or
    //      end points just past the last non-whitespace character (it might point
    //      at the '\0' terminator, in which case there's no problem writing
    //      another there).    
    *end = '\0';

    return s;
}

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

これまでの回答のほとんどは、次のいずれかを実行します。

文字列の終わりでバックトラックします（つまり、文字列の末尾を見つけて、スペース以外の文字が見つかるまで後方にシークします)、または
電話 strlen() まず、文字列全体に 2 回目のパスを実行します。

このバージョンでは 1 回のパスのみを実行し、バックトラックは行いません。したがって、末尾に数百のスペースがあるのが一般的である場合に限りますが (SQL クエリの出力を処理する場合には珍しいことではありません)、他のものよりもパフォーマンスが向上する可能性があります。

static char const WHITESPACE[] = " \t\n\r";

static void get_trim_bounds(char  const *s,
                            char const **firstWord,
                            char const **trailingSpace)
{
    char const *lastWord;
    *firstWord = lastWord = s + strspn(s, WHITESPACE);
    do
    {
        *trailingSpace = lastWord + strcspn(lastWord, WHITESPACE);
        lastWord = *trailingSpace + strspn(*trailingSpace, WHITESPACE);
    }
    while (*lastWord != '\0');
}

char *copy_trim(char const *s)
{
    char const *firstWord, *trailingSpace;
    char *result;
    size_t newLength;

    get_trim_bounds(s, &firstWord, &trailingSpace);
    newLength = trailingSpace - firstWord;

    result = malloc(newLength + 1);
    memcpy(result, firstWord, newLength);
    result[newLength] = '\0';
    return result;
}

void inplace_trim(char *s)
{
    char const *firstWord, *trailingSpace;
    size_t newLength;

    get_trim_bounds(s, &firstWord, &trailingSpace);
    newLength = trailingSpace - firstWord;

    memmove(s, firstWord, newLength);
    s[newLength] = '\0';
}

これは私が考えることができる最短の実装です。

static const char *WhiteSpace=" \n\r\t";
char* trim(char *t)
{
    char *e=t+(t!=NULL?strlen(t):0);               // *e initially points to end of string
    if (t==NULL) return;
    do --e; while (strchr(WhiteSpace, *e) && e>=t);  // Find last char that is not \r\n\t
    *(++e)=0;                                      // Null-terminate
    e=t+strspn (t,WhiteSpace);                           // Find first char that is not \t
    return e>t?memmove(t,e,strlen(e)+1):t;                  // memmove string contents and terminator
}

これらの関数は元のバッファを変更するため、動的に割り当てられた場合、元のポインターを解放できます。

#include <string.h>

void rstrip(char *string)
{
  int l;
  if (!string)
    return;
  l = strlen(string) - 1;
  while (isspace(string[l]) && l >= 0)
    string[l--] = 0;
}

void lstrip(char *string)
{
  int i, l;
  if (!string)
    return;
  l = strlen(string);
  while (isspace(string[(i = 0)]))
    while(i++ < l)
      string[i-1] = string[i];
}

void strip(char *string)
{
  lstrip(string);
  rstrip(string);
}

ヘッダー Shlwapi.h で定義されている StrTrim 関数の使用についてどう思いますか?自分で定義するのではなく、簡単です。
詳細は以下でご覧いただけます。
http://msdn.microsoft.com/en-us/library/windows/desktop/bb773454(v=vs.85).aspx

あなたが持っている場合
char ausCaptain[]="GeorgeBailey ";
StrTrim(ausCaptain," ");
これにより、 ausCaptain として "GeorgeBailey" ない "GeorgeBailey ".

双方から弦をトリミングするために、私はオールディーを使用しますが、gooody;）それは、ASCIIでスペースよりも少ないものをトリミングできます。つまり、コントロールチャーもトリミングされます！

char *trimAll(char *strData)
{
  unsigned int L = strlen(strData);
  if(L > 0){ L--; }else{ return strData; }
  size_t S = 0, E = L;
  while((!(strData[S] > ' ') || !(strData[E] > ' ')) && (S >= 0) && (S <= L) && (E >= 0) && (E <= L))
  {
    if(strData[S] <= ' '){ S++; }
    if(strData[E] <= ' '){ E--; }
  }
  if(S == 0 && E == L){ return strData; } // Nothing to be done
  if((S >= 0) && (S <= L) && (E >= 0) && (E <= L)){
    L = E - S + 1;
    memmove(strData,&strData[S],L); strData[L] = '\0';
  }else{ strData[0] = '\0'; }
  return strData;
}

これまでに投稿したコードは最適ではないと思われるため、コードのみを含めます (コメントする担当者がまだいません)。

void inplace_trim(char* s)
{
    int start, end = strlen(s);
    for (start = 0; isspace(s[start]); ++start) {}
    if (s[start]) {
        while (end > 0 && isspace(s[end-1]))
            --end;
        memmove(s, &s[start], end - start);
    }
    s[end - start] = '\0';
}

char* copy_trim(const char* s)
{
    int start, end;
    for (start = 0; isspace(s[start]); ++start) {}
    for (end = strlen(s); end > 0 && isspace(s[end-1]); --end) {}
    return strndup(s + start, end - start);
}

strndup() は GNU 拡張機能です。それまたは同等のものを持っていない場合は、自分でロールしてください。例えば：

r = strdup(s + start);
r[end-start] = '\0';

ここでは動的メモリ割り当てを使用して、入力文字列を関数trimStrにトリミングします。まず、入力文字列に空でない文字が何文字存在するかを調べます。次に、そのサイズで文字配列を割り当て、NULL 終了文字を処理します。この関数を使用するときは、main 関数内のメモリを解放する必要があります。

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

char *trimStr(char *str){
char *tmp = str;
printf("input string %s\n",str);
int nc = 0;

while(*tmp!='\0'){
  if (*tmp != ' '){
  nc++;
 }
 tmp++;
}
printf("total nonempty characters are %d\n",nc);
char *trim = NULL;

trim = malloc(sizeof(char)*(nc+1));
if (trim == NULL) return NULL;
tmp = str;
int ne = 0;

while(*tmp!='\0'){
  if (*tmp != ' '){
     trim[ne] = *tmp;
   ne++;
 }
 tmp++;
}
trim[nc] = '\0';

printf("trimmed string is %s\n",trim);

return trim; 
 }


int main(void){

char str[] = " s ta ck ove r fl o w  ";

char *trim = trimStr(str);

if (trim != NULL )free(trim);

return 0;
}

これが私のやり方です。文字列がその場でトリミングされるため、返された文字列の割り当てが解除されたり、割り当てられた文字列へのポインタが失われる心配はありません。これは可能な限り最短の答えではないかもしれませんが、ほとんどの読者には明らかなはずです。

#include <ctype.h>
#include <string.h>
void trim_str(char *s)
{
    const size_t s_len = strlen(s);

    int i;
    for (i = 0; i < s_len; i++)
    {
        if (!isspace( (unsigned char) s[i] )) break;
    }

    if (i == s_len)
    {
        // s is an empty string or contains only space characters

        s[0] = '\0';
    }
    else
    {
        // s contains non-space characters

        const char *non_space_beginning = s + i;

        char *non_space_ending = s + s_len - 1;
        while ( isspace( (unsigned char) *non_space_ending ) ) non_space_ending--;

        size_t trimmed_s_len = non_space_ending - non_space_beginning + 1;

        if (s != non_space_beginning)
        {
            // Non-space characters exist in the beginning of s

            memmove(s, non_space_beginning, trimmed_s_len);
        }

        s[trimmed_s_len] = '\0';
    }
}

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow