函数中的Return语句从不打印到屏幕

Question

我试图将一些参数传递给一个函数，并将这些值存储到结构中的一组元素中。 然后通过调用另一个函数从结构中打印这些值。

这是我想做的事情：

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

typedef struct temp
{
    int num;
    char * name;
    struct temp * nextPtr;
}temp;

temp * test();
char * printTest(temp * print);

int main (void)
{
    test("TV",200);
    struct temp * t;
    printTest(t);
    return 0;
}

temp * test(char * name, int num)
{
    struct temp * mem = malloc(sizeof(struct temp));
    mem->name = malloc(sizeof(strlen(name) + 1));
    mem->name = name;

    mem->num = num;
    mem->nextPtr = NULL;
    return mem;
}

char * printTest(temp * print)
{
    char * output;

    output = malloc(sizeof(struct temp));
    print = malloc(sizeof(struct temp));

    sprintf(output,"It's name is %s, and it costs %d",print->name,print->num);
    return output; //should print "TV" and costs "200"
}

函数printTest似乎没有打印出任何东西，而是如果我在其中进行printf硬核化，它将打印空值和零。 但是，我尝试在test函数中打印结构值，该函数在初始化值后确实起作用。

例如，如果我执行printf("%d",mem->num); 这确实会打印出200（在test功能中）的值。

但是最后一个函数中的sprintf和return组合不会得到相同的结果。 任何帮助将非常感激！

Answer 1

您没有捕获从测试返回的值，因此它会丢失：

int main (void)
{
    //changed to capture return value of test.
    struct temp * t = test("TV",200);
    printTest(t);
    return 0;
}

另外，您的打印功能是错误的：

// this now points to the struct you allocated in test.
char * printTest(temp * print)
{
    char * output;

    // you don't really want the size of temp here, you want the size
    // of your formatted string with enough room for all members of the 
    // struct pointed to by temp.
    output = malloc(sizeof(struct temp));

    // you're not using this.
    print = malloc(sizeof(struct temp));

    // you sprintf from a buffer pointing to nothing, into your output buffer
    // writing past the memory you actually allocated.
    sprintf(output,"It's name is %s, and it costs %d",print->name,print->num);

    // return doesn't print anything, it simply returns the value that your
    // function signature specifies, in this case char *
    return output; //should print "TV" and costs "200"
}

试试这个，您将获取分配的指针，并使用printf将格式化的字符串写入stdout：

// we're not returning anything
void printTest(temp * print ){
    if (temp == NULL ){
        // nothing to print, just leave.
        return;
    }

    printf("It's name is %s, and it costs %d",print->name,print->num);
    return;
}

还有一些关于测试功能的注意事项：

// char is a pointer to a string, from your invocation in main, this is
// a string stored in static read only memory
temp * test(char * name, int num)
{
    // you malloc memory for your struct, all good.
    struct temp * mem = malloc(sizeof(struct temp));

    // you malloc space for the length of the string you want to store.
    mem->name = malloc(sizeof(strlen(name) + 1));
    // here's a bit of an issue, mem->name is a pointer, and name is a pointer.
    // what you're doing here is assigning the pointer name to the variable 
    // mem->name, but you're NOT actually copying the string - since you 
    // invoke this method with a static string, nothing will happen and
    // to the string passed in, and you'll be able to reference it - but
    // you just leaked memory that you allocated for mem->name above.
    mem->name = name;

    // num is not apointer, it's just a value, therefore it's okay to assign
    // like this.
    mem->num = num;
    mem->nextPtr = NULL;
    return mem;
}

尝试以下方法：

temp * test(char * name, int num)
{
    struct temp * mem = malloc(sizeof(struct temp));

    // we still malloc room for name, storing the pointer returned by malloc
    // in mem->name
    mem->name = malloc(sizeof(strlen(name) + 1));
    // Now, however, we're going to *copy* the string stored in the memory location
    // pointed to by char * name, into the memory location we just allocated, 
    // pointed to by mem->name
    strcpy(mem->name, name);

    mem->num = num;
    mem->nextPtr = NULL;
    return mem;
}

Answer 2

问题多于乍一看。 这是一个清理的版本。 您不能分配字符串（例如mem->name = name; ）。 您可以为mem->name分配，然后为其分配strncpy名称，或者使用strdup一次分配和复制。 在printTest ，您必须为output分配足够的空间，以容纳格式字符串的静态部分以及 print->name和print->num 。 查看以下内容，如果您有任何疑问，请告诉我。

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

typedef struct temp
{
    int num;
    char * name;
    struct temp * nextPtr;
}temp;

temp * test(char * name, int num);
char * printTest(temp * print);

int main (void)
{
    struct temp * t = test("TV",200);
    // struct temp * t;
    printf ("%s\n", printTest(t));
    return 0;
}

temp * test(char * name, int num)
{
    struct temp * mem = malloc(sizeof(struct temp));
    // mem->name = malloc(sizeof(strlen(name) + 1));
    // mem->name = name;
    mem->name = strdup (name);

    mem->num = num;
    mem->nextPtr = NULL;
    return mem;
}

char * printTest(temp * print)
{
    char *output = NULL;

    // output = malloc(sizeof(struct temp));
    // print = malloc(sizeof(struct temp));

    output = malloc (strlen (print->name) + sizeof print->num + 30);

    sprintf(output,"It's name is %s, and it costs %d",print->name,print->num);

    return output; //should print "TV" and costs "200"
}

产量

$ ./bin/struct_rtn
It's name is TV, and it costs 200

Answer 3

此外， sprintf输出为字符串。 与printf不同，它不会输出到标准输出，即打印到屏幕。 您可能要调用printf或puts放在output字符串上。

Answer 4

这行：'sprintf（输出，“它的名字是％s，花费％d”，print->名称，print-> num）'需要一些重大修改。 1）源字段“ print-> name和print-> num在分配的内存段内，但是它们从未设置为任何特定值，因此它们包含垃圾内容。目标指针'output'指向分配的内存区域，但是该区域不大于源区域（通常，它应该被格式化为“临时”结构，而不是一个长字符串。并且由于它只是临时结构的大小，因此sprintf format参数中的所有多余字符都没有空间，结果将是不确定的行为，因为sprintf的输出将超出分配的内存区域