时间戳

首页 > 解决方案 > 我正在编写代码，在其中创建人，与他们结婚，让他们生育等，但我无法打印它们

c - 我正在编写代码，在其中创建人，与他们结婚，让他们生育等，但我无法打印它们

问题描述

所以起初，我不知道我必须使用 struct 所以我失败了，不得不更改我的整个代码，但现在它无法打印任何东西:(

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

struct p {
    char* name;
    int year_of_birth;
    char* sex;
    struct p* mother;
    struct p* father;
    struct p* significant_other;
    struct p** children;


}typedef Person;

这是我定义我的结构的地方

Person* person_constructor(char *name, int year_of_birth, char *sex);
Person* birth(char *name, int year_of_birth, char *sex, Person *mother);

void display_person(Person* p);
void marry_them(Person *p1, Person *p2);
void display_family(Person* family[], int n);
Person* sibling(Person p, int print);

这是我的函数定义

int main() {
    Person* p1 = person_constructor("Abbas", 1970, "male");
    Person* p2 = person_constructor("Sidika", 1970, "female");
    marry_them(p1, p2);
    Person* p3 = person_constructor("Pinar", 1990, "female");
    Person* p4 = birth("Siamak", 1990, "male", p2);
    marry_them(p3, p4);
    Person* p5 = birth("Guzide", 1990, "female", p2);
    Person* p6 = person_constructor("Fatih", 1990, "male");
    marry_them(p5, p6);
    Person* p7 = birth("Berkecan", 2010, "male", p3);
    Person* p8 = birth("Ekinsu", 2010, "female", p3);
    Person* p9 = birth("Canim", 2010, "female", p5);



    display_person(p1);

我主要的地方，我召唤人们，嫁给他们等等，最重要的部分，

return 0;
}
Person* person_constructor(char *name, int year_of_birth, char *sex)
{
    Person *p = calloc(1,sizeof(*p));
    strcpy(p->name, name);
    p->year_of_birth = year_of_birth;
    strcpy(p->sex, sex);


    return p;
}



void display_person(Person* p)
{

    printf("================\n");
    printf("Name   : %s \n",p->name);
    printf("Sex    : %s \n",p->sex);
    printf("Year   : %d \n",p->year_of_birth);
    if (strcmp(p->father,"") == 0){
        printf("Father : NA \n");
    }
    else {
        printf("Father : %s \n", p->father);
    }
    if (strcmp(p->mother,"") == 0){
        printf("Mother : NA \n");
    }
    else {
        printf("Mother : %s \n", p->mother);
    }
    if (strcmp((const char *) p->significant_other, "") == 0){
        printf("Sig.O  : NA \n");
    }
    else {
        printf("Sig.O  : %s \n", p->significant_other);
    }
    if (strcmp(p->children,"") == 0){
        printf("Child 1 : NA \n");
    }
    else {
        printf("Child 1 : %s \n", p->children[0]);
    }
    if (strcmp(p->children,"") == 0){
        printf("Child 2 : NA \n");
    }
    else {
        printf("Child 2 : %s \n", p->children[1]);
    }
}

void marry_them(Person *p1, Person *p2)
{
    strcpy(p1->significant_other, p2->name);
    strcpy(p2->significant_other, p1->name);

}
Person* birth(char *name, int year_of_birth, char *sex, Person *mother) {
    Person *p = person_constructor(name, year_of_birth, sex);
    strcpy(p->mother, mother->name);
    strcpy(p->father, mother->significant_other);

    return p;
}
void display_family(Person* family[], int n)
{
for (int i = 0;i<n;i++)
{
   display_person(family[i]);
}
}
Person* sibling(Person p, int print)
{


}

这些是我的函数，我为 char mom[20] 类型的代码而不是 struct mom 编写了它们，我很纠结。我无法打印出人类信息，它应该如下所示：

================ 
Name   : Steven
Sex    : male 
Year   : 1970 
Father : NA 
Mother : NA 
Sig.O  : Eva
Child 1: Laura
Child 2: Alice 
================

上面的代码只是我在主要代码中使用的没有名称的表示，只是为了让你明白它的意思。提前致谢！

标签： c

解决方案

就目前而言，一个人已经定义：

人

然后一个calloc用来获取这个的实例：

calloc 人

这很好，但请注意指针无效。strcpy将在无效指针上是未定义的行为。一种可能p->name = name，这将导致编译器指向name参数name：

p->名字=名字

由于使用的是静态常量名称，因此名称永远不会消失，也不会改变。这很好，只要一个人控制name来自哪里。假设在传递给 ; 之前name输入到一个临时的；只要存在潜在的临时变量，就只会定义一个。避免这种情况的常用方法是复制。char *person_constructorname

Person *p;
char *pname;
size_t name_len = strlen(name);
p = calloc(1, sizeof *p + name_len + 1);
if(!p) return 0;
pname = (char *)(p + 1);
strcpy(name, pname);
p->name = pname;

这会将参数复制name到新形成p的空格之后p，（因为分配了那个空间。）另一种选择是分配固定的最大字符数name[200]并将名称直接复制进去，（注意strcpy不要导致溢出.)

strcmp(p->father,""),struct p在它期望的时候通过const char *（参见文档。）该strcmp函数对 , 一无所知struct p，但会很高兴地返回无关的值或崩溃。我建议在构造函数中将father显式设置为0(NULL)，（不保证全字节为零，）然后一个可以printf("Father : %s \n", p->father ? p->father->name : "N/A");。

与孩子一样，除了birth会导致数组增长。如果它是一个动态数组，则需要realloc一些东西。另一种方法是分配固定的最大子节点数。

推荐阅读