Question

所以我在这里有一个程序，在用

调用时效果很好

$ gcc test.c -o test -std=c99

但是在makefile中调用时：

all: test

test: test.c
    gcc test.c -o test -std=c99

它会产生一些警告而产生分段错误。

终端输出：

gcc -g test.c -o tester -std=c99
test.c: In function ‘test_split’:
test.c:43:2: warning: implicit declaration of function‘strdup[-Wimplicit-function-declaration]
  char *str_cpy = strdup(str); // Allow mutation of original string
test.c:43:18: warning: initialization makes pointer from integer without a cast [enabled by default]
  char *str_cpy = strdup(str); // Allow mutation of original string

以上错误不会出现，也不会产生分段错误。

失败的代码段在这里。 string.h包含在头文件中。该文件只是一个大文件来测试其他功能。

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

#define CNRM "\x1b[0m" 
#define CRED "\x1b[31m"
#define CGRN "\x1b[32m"

int stringsum(char *s);
void stringsum2(char *s, int *res);
int distance_between(char *s, char c);
char *string_between(char *s, char c);
char **split(char *s);

static int test_num = 1;

static void logger(int passed, char *s)
{
    char *res;
    char *color;

if (passed) {
    res = "PASS";
    color = CGRN;
} else {
    res = "FAIL";
    color = CRED;
}
printf("[Test %d][%s%s%s] %s\n", test_num++, color, res, CNRM, s);
}

static void test_split(char *str, char **correct)
{
int i, pass = 1;
char buf[512] = { 0 };
char *str_cpy = strdup(str); // Allow mutation of original string
char **res = split(str_cpy);

if (!res || !res[0]) {
    pass = 0;
    sprintf(buf, "split() returned NULL or an empty array");
    goto end;
}

for (i = 0; correct[i]; i++) {
    if (!res[i]) {
        pass = 0;
        sprintf(buf, "split() returned fewer words than expected");
        goto end;
    }
}

if (res[i]) {
    pass = 0;
    sprintf(buf, "split() returned more words than expected");
    goto end;
}

sprintf(buf, "\n%-16s%-16s\n", "Returned", "Expected");

for (i = 0; res[i]; i++) {
    char tmp[256] = { 0 };
    sprintf(tmp, "%-16s%-16s\n", res[i], correct[i]);
    strcat(buf, tmp);
    if (strcmp(res[i], correct[i])) {
        pass = 0;
        goto end;
    }
}

end:
logger(pass, buf);
free(str_cpy);
}

static void test_stringsum(char *input, int expected)
{
int test;
char buf[256] = { 0 };

test = stringsum(input);
sprintf(buf, "Returned: %d, Expected: %d", test, expected);
logger(test == expected, buf);
}

static void test_distance_between(char *str, char c, int expected)
{
int test;
char buf[256] = { 0 };

test = distance_between(str, c);
sprintf(buf, "Returned: %d, Expected: %d", test, expected);
logger(test == expected, buf);
}

static void test_string_between(char *str, char c, const char *expected)
{
char *res_char;
char buf[256] = { 0 };

res_char = string_between(str, c);
snprintf(buf, sizeof(buf), "Returned: %s, Expected: %s", res_char, expected);

if (!res_char && expected) {
    logger(0, buf);
} else {
    if (!expected)
        logger(!res_char, buf);
    else
        logger(!strcmp(res_char, expected), buf);
    free(res_char);
}
}

static void test_stringsum2(char *input, int expected)
{
int res_int;
char buf[256] = { 0 };

stringsum2(input, &res_int);
sprintf(buf, "Returned: %d, Expected: %d", res_int, expected);
logger(res_int == expected, buf);
}

int main(void)
{
printf("Testing stringsum()\n");
test_stringsum("abcd", 10);
test_stringsum("a!", -1);
test_stringsum("aAzZ", 54);
test_stringsum("ababcDcabcddAbcDaBcabcABCddabCddabcabcddABCabcDd", 120);
test_stringsum("", 0);

test_num = 1;
printf("\nTesting distance_between()\n");
test_distance_between("a1234a", 'a', 5);
test_distance_between("a1234", 'a', -1);
test_distance_between("123456a12334a123a", 'a', 6);
test_distance_between("", 'a', -1);

test_num = 1;
printf("\nTesting string_between()\n");
test_string_between("a1234a", 'a', "1234");
test_string_between("a1234", 'a', NULL);
test_string_between("A123adette er svaretaasd2qd3asd12", 'a', "dette er sv");
test_string_between("", 'a', NULL);

test_num = 1;
printf("\nTesting stringsum2()\n");
test_stringsum2("abcd", 10);
test_stringsum2("abcd!", -1);
test_stringsum2("bbbdbbbbbdbbdbbbbbddbbbbbdbbdbbbbdbd", 90);
test_stringsum2("", 0);

test_num = 1;
printf("\nTesting split()\n");
test_split("abcd", (char *[]){ "abcd", NULL });
test_split("Hei du", (char *[]){ "Hei", "du", NULL });
test_split("Dette er mange ord", (char *[]){ "Dette", "er", "mange", "ord", NULL });
return 0;
}

有什么想法吗？

编辑：添加完整代码。

Answer 1

strdup()定义了一系列标准（SVr4,4.3BSD，POSIX.1-2001），但不是C标准。如果您指定-std=c99，则默认情况下 gcc 会禁用这些标准中定义的功能。关于＆＃34;隐含声明＆＃34;的警告是因为C具有（令人讨厌的）遗留功能，如果你只是使用某些规则（例如返回类型int）来隐式声明函数，在这种情况下，这些规则与char*的作业不匹配}。这些警告应该始终修复。

在这种情况下，使用-std=c99可以使用feature test macros修复此问题。

链接的手册页告诉我们将在哪些情况下包含函数声明，例如，这将构建它而不会出现问题：

gcc test.c -o test -std=c99 -D_POSIX_C_SOURCE=200809L

或使用 gcc ，您可以使用它，它可以启用libc的几乎所有功能。

gcc test.c -o test -std=c99 -D_GNU_SOURCE

在包含相关系统标头之前，您还可以将 .c 文件中的定义添加为普通#define 。尽管将它放在与-std=c99相同的位置（即命令行选项）可能会更好，因为在这里它有点与之相配。

更极端的解决方案是切换到-std=gnu99。但仔细考虑这样做，因为很容易意外地使用不是标准C的语言功能。然后你会遇到更多的移植麻烦，而不仅仅是编写一些函数，如果你需要将软件移植到没有GNU扩展的其他C编译器。

Answer 2

如果你问gcc是否符合C99标准，它会按照你的要求去做，忘记它曾经知道strdup() - 这个功能不在C99标准中，但只是POSIX，所以{{1在C99模式下的头文件中没有任何地方。

由于你的代码因为那个原因没有看到原型，并且不知道strdup将返回一个指针而是假设一个整数，它可能会在32-时做各种各样的破坏/ 64-生成strdup ()的混合模式代码。

简单的补救措施：不要尝试在c99模式下使用(sizeof(int) != sizeof(char*))。

为什么您在使用make进行编译时似乎看到了错误，而不是我们无法从您提供的信息中扣除的内容。我想由于某些原因，在使用命令行时你不能将gcc切换到c99模式。

当makefile调用GCC时，C程序将不会在没有警告的情况下编译 - 否则

2 个答案: