如何在C语言中从字符串中删除最后几个字符？

Question

我知道我可以使用substr()函数获取字符串的前n个字符。不过，我想删除最后几个字符。在C语言中，是否可以像在Python中那样使用-2或-3作为结束位置呢？

- TheRookierLearner

Answer 1

您可以简单地将一个空终止字符放在您希望字符串结束的位置，如下所示：

int main()
{
    char s[] = "I am a string";
    int len = strlen(s);
    s[len-3] = '\0';
    printf("%s\n",s);
}

这将为您提供：

"我是一个str"

- Lefteris

---

值得注意的是，这样做能够成功是因为s是一个字符缓冲区而不是一个常量字符串。 - nneonneo

是的，确实，在许多情况下，在[C]标签中会出现这样的问题：为什么使用char* s这样的字符串字面值时，代码会崩溃。 - Lefteris

Answer 2

C语言与Python不同，字符串索引并不是“智能”的。说 str[-3] 的意思就是“在开头之前三个字节的字符”；访问这块内存是未定义行为。

如果你想要将一个字符串的最后几个字符作为另一个字符串返回，只需获取指向所需第一个字符的指针即可：

char *endstr = str + (strlen(str) - 3); // get last 3 characters of the string

如果你想要删除最后几个字符，只需要将倒数第k个字符设置为null (\0) 即可。

str[strlen(str)-3] = 0; // delete last three characters

- nneonneo

Answer 3

这是一个可能的实现substr()函数的代码，包括测试代码。请注意，测试代码没有推动边界 - 缓冲区长度小于所请求的字符串或缓冲区长度为零。

#include <string.h>

extern void substr(char *buffer, size_t buflen, char const *source, int len);

/*
** Given substr(buffer, sizeof(buffer), "string", len), then the output
** in buffer for different values of len is:
** For positive values of len:
** 0    ""
** 1    "s"
** 2    "st"
** ...
** 6    "string"
** 7    "string"
** ...
** For negative values of len:
** -1   "g"
** -2   "ng"
** ...
** -6   "string"
** -7   "string"
** ...
** Subject to buffer being long enough.
** If buffer is too short, the empty string is set (unless buflen is 0,
** in which case, everything is left untouched).
*/
void substr(char *buffer, size_t buflen, char const *source, int len)
{
    size_t srclen = strlen(source);
    size_t nbytes = 0;
    size_t offset = 0;
    size_t sublen;

    if (buflen == 0)    /* Can't write anything anywhere */
        return;
    if (len > 0)
    {
        sublen = len;
        nbytes = (sublen > srclen) ? srclen : sublen;
        offset = 0;
    }
    else if (len < 0)
    {
        sublen = -len;
        nbytes = (sublen > srclen) ? srclen : sublen;
        offset = srclen - nbytes;
    }
    if (nbytes >= buflen)
        nbytes = 0;
    if (nbytes > 0)
        memmove(buffer, source + offset, nbytes);
    buffer[nbytes] = '\0';
}

#ifdef TEST

#include <stdio.h>

struct test_case
{
    const char *source;
    int         length;
    const char *result;
};

static struct test_case tests[] =
{
    {   "string",  0, ""            },
    {   "string", +1, "s"           },
    {   "string", +2, "st"          },
    {   "string", +3, "str"         },
    {   "string", +4, "stri"        },
    {   "string", +5, "strin"       },
    {   "string", +6, "string"      },
    {   "string", +7, "string"      },
    {   "string", -1, "g"           },
    {   "string", -2, "ng"          },
    {   "string", -3, "ing"         },
    {   "string", -4, "ring"        },
    {   "string", -5, "tring"       },
    {   "string", -6, "string"      },
    {   "string", -7, "string"      },
};
enum { NUM_TESTS = sizeof(tests) / sizeof(tests[0]) };

int main(void)
{
    int pass = 0;
    int fail = 0;

    for (int i = 0; i < NUM_TESTS; i++)
    {
        char buffer[20];
        substr(buffer, sizeof(buffer), tests[i].source, tests[i].length);
        if (strcmp(buffer, tests[i].result) == 0)
        {
            printf("== PASS == %2d: substr(buffer, %zu, \"%s\", %d) = \"%s\"\n",
                   i, sizeof(buffer), tests[i].source, tests[i].length, buffer);
            pass++;
        }
        else
        {
            printf("!! FAIL !! %2d: substr(buffer, %zu, \"%s\", %d) wanted \"%s\" actual \"%s\"\n",
                   i, sizeof(buffer), tests[i].source, tests[i].length, tests[i].result, buffer);
            fail++;
        }
    }
    if (fail == 0)
    {
        printf("== PASS == %d tests passed\n", NUM_TESTS);
        return(0);
    }
    else
    {
        printf("!! FAIL !! %d tests out of %d failed\n", fail, NUM_TESTS);
        return(1);
    }
}

#endif /* TEST */

函数声明应该在适当的头文件中。变量sublen可帮助代码在以下情况下编译得更加干净：

gcc -O3 -g -std=c99 -Wall -Wextra -Wmissing-prototypes -Wstrict-prototypes \
        -Wold-style-definition -Werror -DTEST substr.c -o substr 

测试结果：

== PASS ==  0: substr(buffer, 20, "string", 0) = ""
== PASS ==  1: substr(buffer, 20, "string", 1) = "s"
== PASS ==  2: substr(buffer, 20, "string", 2) = "st"
== PASS ==  3: substr(buffer, 20, "string", 3) = "str"
== PASS ==  4: substr(buffer, 20, "string", 4) = "stri"
== PASS ==  5: substr(buffer, 20, "string", 5) = "strin"
== PASS ==  6: substr(buffer, 20, "string", 6) = "string"
== PASS ==  7: substr(buffer, 20, "string", 7) = "string"
== PASS ==  8: substr(buffer, 20, "string", -1) = "g"
== PASS ==  9: substr(buffer, 20, "string", -2) = "ng"
== PASS == 10: substr(buffer, 20, "string", -3) = "ing"
== PASS == 11: substr(buffer, 20, "string", -4) = "ring"
== PASS == 12: substr(buffer, 20, "string", -5) = "tring"
== PASS == 13: substr(buffer, 20, "string", -6) = "string"
== PASS == 14: substr(buffer, 20, "string", -7) = "string"
== PASS == 15 tests passed

在另一个答案的评论中，cool_sops问道：

为什么这样不行：memcpy(new_string, old_string, strlen(old_string) - 3; &new_string[strlen(old_string) - 3] = '\0' 假设new_string和old_string都是char指针且strlen(old_string) > 3？

假设您删除了&，插入了缺失的)和;，指针指向有效的非重叠位置，并且长度条件得到满足，那么就可以将旧字符串除最后3个字符外的所有内容复制到新字符串中。您可以通过将其嵌入到一些测试代码中进行测试。它并没有尝试处理复制旧字符串的最后三个字符，这似乎是问题的主要关注点。

#include <string.h>
#include <stdio.h>
int main(void)
{
    char new_string[32] = "XXXXXXXXXXXXXXXX";
    char old_string[] = "string";
    memcpy(new_string, old_string, strlen(old_string) - 3);
    new_string[strlen(old_string) - 3] = '\0';
    printf("<<%s>> <<%s>>\n", old_string, new_string);
    return(0);
}

输出：

<<string>> <<str>>

但要小心棘手的巧合；我选择了一个6个字符长的旧字符串样本，-3也会使'length -3'等于3。要获取最后N个字符，您需要编写更像这样的代码：

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

int main(void)
{
    int  N = 3;
    char new_string[32] = "XXXXXXXXXXXXXXXX";
    char old_string[] = "dandelion";
    int  sublen = strlen(old_string) - N;

    assert(sublen > 0);
    memcpy(new_string, old_string + sublen, N);
    new_string[N] = '\0';
    printf("<<%s>> <<%s>>\n", old_string, new_string);
    return(0);
}

输出：

<<dandelion>> <<ion>>

请注意，编写这样的小程序是很好的练习，也有教育意义。写更多的代码是提高编写代码能力的一种方式。

唯一需要注意的陷阱是，如果你在测试“未定义的行为”，你只会从单个编译器得到响应，但其他编译器可能生成行为不同的代码。这段代码没有涉及到未定义的行为，所以没问题。识别未定义的行为很棘手，所以你可以部分忽略这些评论，但请确保使用你能承受的严格警告选项来编译你的代码——它们有助于识别未定义的行为。

我有一些示例程序供参考（在源代码控制下），存放在一个名为“vignettes”的目录中；它们是展示我可能将来需要的技巧的小程序。它们是完整的，它们能够工作（它们比这些特定的示例更复杂，但我已经编写C程序比你更长时间了）；但它们只是玩具——有用的玩具。

- Jonathan Leffler

Answer 4

不，你必须像这样使用strlen()来获取最后几个字符。

substr(strlen(str)-4,3);

请记住，字符串的下标从0开始，因此这会给你最后3个字符。

因此，一般的技巧是

substr(strlen(str)-n-1,n);

（当然，字符串必须比n更长）

如果您想获取最后3个字符，请使用以下代码：

substr(0,strlen(str)-4);

或者一般来说

substr(0,strlen(str)-n-1);

- Hogan

---

这会给我最后3个，还是移除最后3个？因为我想要移除最后3个。 - TheRookierLearner

嘿，我刚注意到这是C++语法而不是C语法。在C中会起作用吗？ - TheRookierLearner

Answer 5

我注意到substr不是标准的C函数，因此在C中使用它是无效的。因此，为了通过消除最后几个字符来查找子字符串，可以使用memcpy(new_string, old_string, strlen(old_string) - 3)

- TheRookierLearner

---

这并不会给你一个以 null 结尾的字符串... 如果 strlen(old_string) < 3，它也会遇到问题。 - Jonathan Leffler

你能指出方法吗？我的意思是使用memcpy或其他方式获取一个空终止字符串？ - TheRookierLearner

@JonathanLeffler - 为什么这段代码无法正常工作：memcpy(new_string, old_string, strlen(old_string) - 3; &new_string[strlen(old_string) - 3] = '\0' 假设 new_string 和 old_string 都是 char 指针且 strlen(old_string) > 3。 - TheRookierLearner