是否有一种干净的，最好是标准的方法从 C 中的字符串中修剪前导和尾随空格？我会自己动手，但我认为这是一个同样常见的解决方案的常见问题。
coledot
问问题
380843 次
39 回答
186
如果可以修改字符串：
// 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;
}
于 2008-09-23T18:12:32.883 回答
41
这是将字符串移动到缓冲区的第一个位置的方法。您可能需要这种行为，以便如果您动态分配字符串，您仍然可以在 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( frontp != str && endp == frontp )
*str = '\0';
else if( str + len - 1 != endp )
*(endp + 1) = '\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;
}
测试正确性：
#include <stdio.h>
#include <string.h>
#include <ctype.h>
/* Paste function from above here. */
int main()
{
/* The test prints the following:
[nothing to trim] -> [nothing to trim]
[ trim the front] -> [trim the front]
[trim the back ] -> [trim the back]
[ trim front and back ] -> [trim front and 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]
[] -> []
*/
char *sample_strings[] =
{
"nothing to trim",
" trim the front",
"trim the back ",
" trim front and back ",
" trim one char front and back ",
" trim one char front",
"trim one char back ",
" ",
" ",
"a",
"",
NULL
};
char test_buffer[64];
char comparison_buffer[64];
size_t index, compare_pos;
for( index = 0; sample_strings[index] != NULL; ++index )
{
// Fill buffer with known value to verify we do not write past the end of the string.
memset( test_buffer, 0xCC, sizeof(test_buffer) );
strcpy( test_buffer, sample_strings[index] );
memcpy( comparison_buffer, test_buffer, sizeof(comparison_buffer));
printf("[%s] -> [%s]\n", sample_strings[index],
trim(test_buffer));
for( compare_pos = strlen(comparison_buffer);
compare_pos < sizeof(comparison_buffer);
++compare_pos )
{
if( test_buffer[compare_pos] != comparison_buffer[compare_pos] )
{
printf("Unexpected change to buffer @ index %u: %02x (expected %02x)\n",
compare_pos, (unsigned char) test_buffer[compare_pos], (unsigned char) comparison_buffer[compare_pos]);
}
}
}
return 0;
}
源文件是 trim.c。使用“cc -Wall trim.c -o trim”编译。
于 2008-09-23T18:48:09.787 回答
25
我的解决方案。字符串必须是可变的。其他一些解决方案的优势在于它将非空格部分移动到开头，因此您可以继续使用旧指针，以防您以后必须 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);
}
于 2008-09-23T20:42:16.037 回答
11
这是我的 C 迷你库，用于修剪左、右、两者、全部、就地和单独，并修剪一组指定的字符（或默认情况下的空白）。
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); }
一个主要程序可以完成所有工作。如果src == dst ，它将就地修剪，否则，它就像strcpy例程一样工作。它修剪字符串delim中指定的一组字符, 如果为空，则为空格。它修剪左、右、两者和所有（如 tr）。它没有太多内容，它只遍历字符串一次。有些人可能会抱怨修剪右侧从左侧开始，但是，无论如何都不需要从左侧开始的 strlen。（你必须以一种或另一种方式到达字符串的末尾以进行正确的修剪，所以你最好边做边做。）关于流水线和缓存大小等可能会有争论——谁知道呢. 由于该解决方案从左到右工作并且只迭代一次，因此它也可以扩展到流上工作。限制：它不适用于unicode字符串。
于 2010-06-15T04:34:02.660 回答
10
这是我对一个简单但正确的就地修剪功能的尝试。
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.
}
于 2010-10-20T07:08:26.423 回答
9
装饰派对迟到了
特点：
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 desired, 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); // older errant code
len = (size_t) (p - s + 1); // Thanks to @theriver
}
return (s == original) ? s : memmove(original, s, len + 1);
}
于 2014-11-17T23:38:52.653 回答
4
这是一个类似于@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();
于 2010-12-22T01:47:36.693 回答
3
另一个，用一条线做真正的工作：
#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);
}
于 2014-06-11T17:16:13.347 回答
3
我不喜欢这些答案中的大多数，因为他们做了以下一项或多项......
- 在原始指针的字符串中返回了一个不同的指针（将两个不同的指针同时指向同一事物有点痛苦）。
- 无偿使用诸如strlen()之类的东西来预迭代整个字符串。
- 使用了非便携式操作系统特定的库函数。
- 反向扫描。
- 使用与' ' 的比较而不是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';
}
于 2015-11-17T12:46:02.503 回答
2
我不确定你认为什么是“无痛”。
C弦非常痛苦。我们可以很容易地找到第一个非空白字符的位置：
而 (isspace(* p)) p++;
我们可以通过两个类似的简单移动找到最后一个非空白字符的位置：
而 (* q) q++;
做{ q--; } 而 (isspace(* q));
（我已经免除了您同时使用*和++运算符的痛苦。）
现在的问题是你怎么处理这个？手头的数据类型实际上并不是一个String很容易思考的强大的抽象抽象，而实际上只是一个存储字节数组。由于缺乏稳健的数据类型，因此不可能编写出与 PHperytonby 的函数相同的chomp函数。C 中的这样一个函数会返回什么？
于 2008-09-23T18:39:59.917 回答
2
使用字符串库，例如：
Ustr *s1 = USTR1(\7, " 12345 ");
ustr_sc_trim_cstr(&s1, " ");
assert(ustr_cmp_cstr_eq(s1, "12345"));...正如您所说，这是一个“常见”问题，是的，您需要包含一个 #include 左右，并且它不包含在 libc 中，但不要发明您自己的 hack 作业来存储随机指针和 size_t 那样只会导致缓冲区溢出。
于 2008-09-24T04:07:53.343 回答
2
如果您正在使用glib，那么您可以使用g_strstrip
于 2016-10-08T11:00:15.803 回答
2
派对迟到了……
无回溯的单程前向扫描解决方案。源字符串中的每个字符都只测试一次两次。（所以它应该比这里的大多数其他解决方案更快，特别是如果源字符串有很多尾随空格。）
这包括两种解决方案，一种是将源字符串复制并修剪为另一个目标字符串，另一种是将源字符串修剪到位。这两个函数使用相同的代码。
（可修改的）字符串被原地移动，因此指向它的原始指针保持不变。
#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);
}
于 2018-07-06T17:20:34.000 回答
1
比赛有点晚了，但我会把我的套路投入到战斗中。它们可能不是最绝对有效的，但我相信它们是正确的并且它们很简单（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));
}
于 2010-03-16T06:08:51.597 回答
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);
}
于 2015-11-08T21:03:26.743 回答
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;
}
于 2017-08-09T05:18:58.407 回答
1
跳过字符串中前导空格的最简单方法是，恕我直言，
#include <stdio.h>
int main()
{
char *foo=" teststring ";
char *bar;
sscanf(foo,"%s",bar);
printf("String is >%s<\n",bar);
return 0;
}
于 2018-04-29T13:22:43.350 回答
1
好的，这是我对这个问题的看法。我相信这是最简洁的解决方案，它可以修改字符串（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;
}
于 2018-10-06T01:00:01.080 回答
1
#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有助于修剪所有空白。
- 运行第一个循环以从最后一个字节检查空格字符并减少长度变量
- 运行第二个循环以从第一个字节开始检查空格字符并减少长度变量并增加 char 指针。
- 最后，如果长度变量大于 0，则用于
strndup通过排除空格来创建新的字符串缓冲区。
于 2018-12-31T15:53:59.937 回答
1
这一个简短而简单，使用 for 循环并且不会覆盖字符串边界。isspace()如果需要，您可以将测试替换为。
void trim (char *s) // trim leading and trailing spaces+tabs
{
int i,j,k, len;
j=k=0;
len = strlen(s);
// find start of string
for (i=0; i<len; i++) if ((s[i]!=32) && (s[i]!=9)) { j=i; break; }
// find end of string+1
for (i=len-1; i>=j; i--) if ((s[i]!=32) && (s[i]!=9)) { k=i+1; break;}
if (k<=j) {s[0]=0; return;} // all whitespace (j==k==0)
len=k-j;
for (i=0; i<len; i++) s[i] = s[j++]; // shift result to start of string
s[i]=0; // end the string
}//_trim
于 2019-09-19T18:24:45.973 回答
0
就个人而言，我会自己动手。您可以使用 strtok，但您需要注意这样做（特别是如果您要删除前导字符），您知道什么是内存。
删除尾随空格很容易，而且非常安全，因为您可以在最后一个空格的顶部放一个 0，从末尾倒数。摆脱领先空间意味着移动事物。如果您想在原地执行此操作（可能是明智的），您可以继续将所有内容移回一个字符，直到没有前导空格。或者，为了更有效，您可以找到第一个非空格字符的索引，然后将所有内容移回该数字。或者，您可以只使用指向第一个非空格字符的指针（但是您需要像使用 strtok 一样小心）。
于 2008-09-23T18:16:02.487 回答
0
我只包括代码，因为到目前为止发布的代码似乎不是最理想的（而且我还没有代表发表评论。）
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';
于 2008-09-23T18:49:55.807 回答
0
#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;
}于 2009-12-04T05:46:21.090 回答
0
到目前为止，大多数答案都执行以下操作之一：
- 回溯到字符串的末尾（即找到字符串的末尾，然后向后搜索，直到找到一个非空格字符）或
- 首先调用
strlen()，然后通过整个字符串进行第二次传递。
这个版本只做一次，不回溯。因此，它可能比其他的性能更好，尽管只有在通常有数百个尾随空格的情况下（这在处理 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';
}
于 2011-05-06T19:34:30.497 回答
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
}
于 2013-02-20T11:33:06.173 回答
0
这些函数会修改原始缓冲区，因此如果动态分配，原始指针可以被释放。
#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);
}
于 2013-05-22T13:49:06.197 回答
0
您如何看待使用头文件 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 "
于 2013-10-18T03:34:05.497 回答
0
为了从两边修剪我的字符串，我使用 oldie 但 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;
}
于 2016-02-23T10:12:27.903 回答
0
这里我使用动态内存分配将输入字符串修剪为函数 trimStr。首先，我们找出输入字符串中有多少个非空字符。然后，我们分配一个具有该大小的字符数组并处理空终止字符。当我们使用这个函数时，我们需要释放主函数内部的内存。
#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;
}
于 2018-02-01T12:41:09.087 回答
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';
}
}
于 2018-06-15T18:57:19.410 回答
0
char* strtrim(char* const str)
{
if (str != nullptr)
{
char const* begin{ str };
while (std::isspace(*begin))
{
++begin;
}
auto end{ begin };
auto scout{ begin };
while (*scout != '\0')
{
if (!std::isspace(*scout++))
{
end = scout;
}
}
auto /* std::ptrdiff_t */ const length{ end - begin };
if (begin != str)
{
std::memmove(str, begin, length);
}
str[length] = '\0';
}
return str;
}
于 2018-08-06T23:35:25.320 回答
0
由于其他答案似乎没有直接改变字符串指针，而是依赖于返回值，我想我会提供这种方法，它另外不使用任何库，因此适用于操作系统风格的编程：
// only used for printf in main
#include <stdio.h>
// note the char ** means we can modify the address
char *trimws(char **strp) {
char *str;
// check if empty string
if(!*str)
return;
// go to the end of the string
for (str = *strp; *str; str++)
;
// back up one from the null terminator
str--;
// set trailing ws to null
for (; *str == ' '; str--)
*str = 0;
// increment past leading ws
for (str = *strp; *str == ' '; str++)
;
// set new begin address of string
*strp = str;
}
int main(void) {
char buf[256] = " whitespace ";
// pointer must be modifiable lvalue so we make bufp
char **bufp = &buf;
// pass in the address
trimws(&bufp);
// prints : XXXwhitespaceXXX
printf("XXX%sXXX\n", bufp);
return 0;
}
于 2019-12-05T20:05:53.220 回答
0
IMO，它可以在没有strlenand的情况下完成isspace。
char *
trim (char * s, char c)
{
unsigned o = 0;
char * sb = s;
for (; *s == c; s++)
o++;
for (; *s != '\0'; s++)
continue;
for (; s - o > sb && *--s == c;)
continue;
if (o > 0)
memmove(sb, sb + o, s + 1 - o - sb);
if (*s != '\0')
*(s + 1 - o) = '\0';
return sb;
}
于 2021-04-24T05:05:02.890 回答
-1
这是一个做你想做的事情的功能。它应该处理字符串都是空格的退化情况。您必须传入一个输出缓冲区和缓冲区的长度，这意味着您必须传入一个您分配的缓冲区。
void str_trim(char *output, const char *text, int32 max_len)
{
int32 i, j, length;
length = strlen(text);
if (max_len < 0) {
max_len = length + 1;
}
for (i=0; i<length; i++) {
if ( (text[i] != ' ') && (text[i] != '\t') && (text[i] != '\n') && (text[i] != '\r')) {
break;
}
}
if (i == length) {
// handle lines that are all whitespace
output[0] = 0;
return;
}
for (j=length-1; j>=0; j--) {
if ( (text[j] != ' ') && (text[j] != '\t') && (text[j] != '\n') && (text[j] != '\r')) {
break;
}
}
length = j + 1 - i;
strncpy(output, text + i, length);
output[length] = 0;
}
循环中的 if 语句可能可以替换为isspace(text[i])或isspace(text[j])以使这些行更易于阅读。我认为我将它们设置为这种方式是因为有些字符我不想测试，但看起来我现在覆盖了所有空格:-)
于 2008-09-23T18:24:20.143 回答
-1
以下是我披露的关于 Linux 内核代码中的问题：
/**
* skip_spaces - Removes leading whitespace from @s.
* @s: The string to be stripped.
*
* Returns a pointer to the first non-whitespace character in @s.
*/
char *skip_spaces(const char *str)
{
while (isspace(*str))
++str;
return (char *)str;
}
/**
* strim - Removes leading and trailing whitespace from @s.
* @s: The string to be stripped.
*
* Note that the first trailing whitespace is replaced with a %NUL-terminator
* in the given string @s. Returns a pointer to the first non-whitespace
* character in @s.
*/
char *strim(char *s)
{
size_t size;
char *end;
size = strlen(s);
if (!size)
return s;
end = s + size - 1;
while (end >= s && isspace(*end))
end--;
*(end + 1) = '\0';
return skip_spaces(s);
}
由于起源，它应该没有错误；-)
我猜我的一件更接近 KISS 原则：
/**
* trim spaces
**/
char * trim_inplace(char * s, int len)
{
// trim leading
while (len && isspace(s[0]))
{
s++; len--;
}
// trim trailing
while (len && isspace(s[len - 1]))
{
s[len - 1] = 0; len--;
}
return s;
}
于 2014-09-26T15:44:26.707 回答
-1
void trim(char* const str)
{
char* begin = str;
char* end = str;
while (isspace(*begin))
{
++begin;
}
char* s = begin;
while (*s != '\0')
{
if (!isspace(*s++))
{
end = s;
}
}
*end = '\0';
const int dist = end - begin;
if (begin > str && dist > 0)
{
memmove(str, begin, dist + 1);
}
}
就地修改字符串，因此您仍然可以将其删除。
不使用花哨的裤子库函数（除非您认为 memmove 很花哨）。
处理字符串重叠。
修剪前后（不是中间，抱歉）。
如果字符串很大，则速度很快（memmove 通常用汇编语言编写）。
仅在需要时移动字符（我发现在大多数用例中都是如此，因为字符串很少有前导空格并且通常没有尾随空格）
我想对此进行测试，但我迟到了。享受寻找错误... :-)
于 2016-02-10T00:54:51.500 回答
-2
#include<stdio.h>
#include<ctype.h>
main()
{
char sent[10]={' ',' ',' ','s','t','a','r','s',' ',' '};
int i,j=0;
char rec[10];
for(i=0;i<=10;i++)
{
if(!isspace(sent[i]))
{
rec[j]=sent[i];
j++;
}
}
printf("\n%s\n",rec);
}
于 2012-07-18T10:18:57.130 回答
-2
C++ STL 风格
std::string Trimed(const std::string& s)
{
std::string::const_iterator begin = std::find_if(s.begin(),
s.end(),
[](char ch) { return !std::isspace(ch); });
std::string::const_iterator end = std::find_if(s.rbegin(),
s.rend(),
[](char ch) { return !std::isspace(ch); }).base();
return std::string(begin, end);
}
于 2016-01-13T12:14:30.027 回答
-2
void trim(char* string) {
int lenght = strlen(string);
int i=0;
while(string[0] ==' ') {
for(i=0; i<lenght; i++) {
string[i] = string[i+1];
}
lenght--;
}
for(i=lenght-1; i>0; i--) {
if(string[i] == ' ') {
string[i] = '\0';
} else {
break;
}
}
}
于 2016-03-09T18:25:10.690 回答