C 返回指向结构的指针

我有一个程序，你可以在两个结构中输入两个日期（相同的类型），然后我需要一个函数来查找我输入的哪个日期是较晚的日期。它只比较年份和月份。一旦找到较晚的日期，我希望函数返回一个指向具有较晚日期的结构的指针。然后我想打印出以后的日期

这是我到目前为止所知道的，但是我得到了错误，并且我不确定指针语法

代码：

#include <stdio.h>

struct date{
     int year;
     int month;
     int day;
};


main()
{
    struct date dates[2];
    int i = 0, res = 0;

    for ( i = 0 ; i < 2 ; i++){
        printf("Enter a year!");
        scanf("%d", &dates[i].year);

        printf("Enter a month!");
        scanf("%d", &dates[i].month);

        printf("Enter a day!");
        scanf("%d", &dates[i].day);
    }

    res = later(&dates[1], &dates[2]);

}

struct date *later(struct date *one, struct date *two)
{

    if (one->year > two->year){
        return *one;
    }       

    else if (one->year == two->year){
        if(one->month > two->month){
            return *one;        
        }   
        else 

        return *two;
    }

    else {
        return *two;    
    }

}

---

正如评论中所指出的，有许多方法可以处理退货。您可以将

later

函数声明为

int

（如您所做），并使用类似于strcmp返回的返回（

0

-日期相等，

-1

first早于last，

1

first晚于last）

您还可以将

later

声明为

struct date*

，并返回指向更晚日期的指针（如果日期相等，则返回什么内容将使您陷入困境）

如果返回一个类似于strcmp的

int

值，则返回的值更有意义。根据第一个更早、等效或更晚的值比较结构日期并返回

-1、0

或

1

的实现可以是：

int later (struct date *one, struct date *two)
{   /* the ternary operator is your friend */
    if (one->year != two->year)     /* years differ  */
        return one->year > two->year ? 1 : -1;

    if (one->month != two->month)   /* months differ */
        return one->month > two->month ? 1 : -1;

    if (one->day != two->day)       /* days differ   */
        return one->day > two->day ? 1 : -1;

    return 0;   /* dates are equivalent */
}

#include <stdio.h>

struct date {
    int year;
    int month;
    int day;
};

int later (struct date *one, struct date *two);
void prn_result (struct date a, struct date b, char op);

/* main is a function of type 'int' and returns a value */
int main (void) {

    struct date dates[2] = {{0}};       /* initialize variables */
    int i = 0, res = 0;

    for (i = 0; i < 2; i++) {           /* user input of dates  */
        printf ("Enter a year: ");
        scanf ("%d", &dates[i].year);

        printf ("Enter a month :");
        scanf ("%d", &dates[i].month);

        printf ("Enter a day: ");
        scanf ("%d", &dates[i].day);

        putchar ('\n');
    }

    res = later (&dates[0], &dates[1]);     /* comparison   */
    if (res == 0)
        prn_result (dates[0], dates[1], '=');
    else if (res > 0)
        prn_result (dates[0], dates[1], '>');
    else
        prn_result (dates[0], dates[1], '<');

    return 0;
}

int later (struct date *one, struct date *two)
{   /* the ternary operator is your friend */
    if (one->year != two->year)     /* years differ  */
        return one->year > two->year ? 1 : -1;

    if (one->month != two->month)   /* months differ */
        return one->month > two->month ? 1 : -1;

    if (one->day != two->day)       /* days differ   */
        return one->day > two->day ? 1 : -1;

    return 0;   /* dates are equivalent */
}

void prn_result (struct date a, struct date b, char op)
{
    printf ("%d/%d/%d %c %d/%d/%d\n",
            a.month, a.day, a.year, op,
            b.month, b.day, b.year);
}

（注意：使用

三元

运算符（例如

测试？如果为真：如果为假

）来简单地比较每个日期组件）

另外，请注意，在这种情况下，您可以自由地传递

struct date

而不是

struct date*

，因为该函数可以在每个

date

struct的副本上正常工作。这取决于你想怎么做

测试函数（并注意一些代码改进）的小样本程序可能是：

int later (struct date *one, struct date *two)
{   /* the ternary operator is your friend */
    if (one->year != two->year)     /* years differ  */
        return one->year > two->year ? 1 : -1;

    if (one->month != two->month)   /* months differ */
        return one->month > two->month ? 1 : -1;

    if (one->day != two->day)       /* days differ   */
        return one->day > two->day ? 1 : -1;

    return 0;   /* dates are equivalent */
}

#include <stdio.h>

struct date {
    int year;
    int month;
    int day;
};

int later (struct date *one, struct date *two);
void prn_result (struct date a, struct date b, char op);

/* main is a function of type 'int' and returns a value */
int main (void) {

    struct date dates[2] = {{0}};       /* initialize variables */
    int i = 0, res = 0;

    for (i = 0; i < 2; i++) {           /* user input of dates  */
        printf ("Enter a year: ");
        scanf ("%d", &dates[i].year);

        printf ("Enter a month :");
        scanf ("%d", &dates[i].month);

        printf ("Enter a day: ");
        scanf ("%d", &dates[i].day);

        putchar ('\n');
    }

    res = later (&dates[0], &dates[1]);     /* comparison   */
    if (res == 0)
        prn_result (dates[0], dates[1], '=');
    else if (res > 0)
        prn_result (dates[0], dates[1], '>');
    else
        prn_result (dates[0], dates[1], '<');

    return 0;
}

int later (struct date *one, struct date *two)
{   /* the ternary operator is your friend */
    if (one->year != two->year)     /* years differ  */
        return one->year > two->year ? 1 : -1;

    if (one->month != two->month)   /* months differ */
        return one->month > two->month ? 1 : -1;

    if (one->day != two->day)       /* days differ   */
        return one->day > two->day ? 1 : -1;

    return 0;   /* dates are equivalent */
}

void prn_result (struct date a, struct date b, char op)
{
    printf ("%d/%d/%d %c %d/%d/%d\n",
            a.month, a.day, a.year, op,
            b.month, b.day, b.year);
}

#包括
结构日期{
国际年；
整月；
国际日；
};
int later（结构日期*1，结构日期*2）；
作废prn_结果（结构日期a、结构日期b、字符op）；
/*main是“int”类型的函数，返回一个值*/
内部主（空）{
结构日期日期[2]={{0}；/*初始化变量*/
int i=0，res=0；
对于（i=0；i<2；i++）{/*用户输入日期*/
printf（“输入年份：”）；
scanf（“%d”，&日期[i].年）；
printf（“输入月份：”）；
scanf（“%d”，&日期[i].月）；
printf（“输入日期：”）；
scanf（“%d”，&dates[i].day）；
putchar（'\n'）；
}
res=以后（&dates[0]，&dates[1]）；/*比较*/
如果（res==0）
prn_结果（日期[0]，日期[1]，'='）；
否则，如果（分辨率>0）
prn_结果（日期[0]，日期[1]，“>”）；
其他的
prn_结果（日期[0]，日期[1]，“您的程序存在多个问题：

您的函数没有原型
later（）

解决方案：
添加
date*later（date*one，date*two）；
在结束结构日期声明后，或将整个函数移到
main（）上方

在返回指向日期对象的指针时，将函数的返回类型更改为
date*
将res的数据类型更改为
date*
，因为您希望存储指向日期对象的指针
然后，通过单独打印对象的每个组件来打印对象res所指向的对象，因为printf不是为打印自定义数据类型而设计的
这只是一个建议，但我建议您将
inti
的声明移动到
for（inti=0；i<2；i++）；
这被认为是更好的方法，可以节省内存
如果希望res是int，则必须返回一个对象而不是指针，然后将其类型转换为int。类型转换指南：
会出现哪些错误？？必须使用正确的返回类型声明函数：
struct date*later（struct date*d1，struct date*d2）
在使用它之前。您必须担心指向的内存是如何管理的；在这种情况下，您将返回传递给函数的两个指针中的一个，这很容易，并将结果捕获到指针中（也很容易）。类似这样的小类型的另一个选项是返回结构类型作为返回值-
struct date later（const struct*d1，const struct*d2）；
res=later（&dates[1]，&dates[2]）；
通过读取超出结构数组末尾的内容调用未定义的行为，可能
res=later（&dates[0]，&dates[1]））；
？？