Question

据我所知，如果结构中的项目是指针，则使用->调用它，如果它是正常值，则使用.。

这里是我的typedef：

typedef struct
{
    char name[50];
    int quantity;
}ing;

typedef struct
{
    char name[50];
    ing *n;
    int price, n_ing, max_producity;
}prod;

然后我宣布prod a;并分配a->n=malloc(n*sizeof(ing));。但是当我尝试访问a.n->name时，它给了我错误。

所有4种组合都给我错误“错误：' - ＆gt;'的无效类型参数（有'prod'（或'ing'））“或”错误：下标值既不是数组也不是指针也不是向量“。

为什么？

    int ret_max_producity(prod a, ing n, int dim_n)
    {
        int max_prod=32100, i;
        for(i=0; i<a.n_ing; i++)
        {
/* here!->*/if((n[find_ing(n, a.n[i]->name, dim_n)].quantity)/(a.n->quantity)<max_prod)
            {
/* here!->*/    max_prod=(n[find_ing(n ,a.n[i]->name, dim_n)].quantity/a.n->quantity);
            }
        }
        if(max_prod==32100)
        {
            printf("ERROR WHILE FINDING MAX PRODUCITY FOR PRODUCT %s, ABORTING", a.name);
            system("pause");
            exit(EXIT_FAILURE);
        }
        return max_prod;
    }

int find_ing(ing v, char *s, int dim)
{
    int i;
    for(i=0; i<dim; i++)
    {
        if(strcmp(s, v.name)==0)
        {
            return i;
        }
    }
    printf("\n\nERROR WHILE FINDING INGREDIENT %s IN VECTOR, ABORTING...", s);
    system("pause");
    exit(EXIT_FAILURE);
}

The errors

Answer 1

如果你宣告一个prod a而不是prod * a，那么你需要通过a.n来访问这些成员。由于n是指针，因此它应该是a.n-＆gt; name。

- ＆GT;仅在有指向结构的指针时使用。。当你有一个结构的实例时使用。

刺激;

a.n = malloc（sizeof（ing *））; //为什么要将这个数乘以n？不要那样做。 a.n =您所创建的实例的地址。 a.n =＆amp; ing结构。

a.n-＆gt; whatever =现在您可以访问此值

编辑：

摆脱defs类型。它应该读

struct Foo{

members
};

struct Foo2{
members
};

那应该没问题。您认为我以错误的方式使用typedef。

struct ing
{
    char name[50];
    int quantity;
};

struct prod
{
    char name[50];
    ing *n;
    int price, n_ing, max_producity;
};

您还需要传递这两个结构的地址，然后从中获取指针。所以你的函数声明应该是：

int ret_max_producity(prod * a, ing  *n, int dim_n)

当调用ret_max_productivity时，它应该：

ret_max_productivity(&a, &n, int dim_n);

Answer 2

As far as I know, if the item inside a structure is a pointer, you call it with ->, if it's a normal value it is used ..

不，.运算符用于访问结构的成员，->运算符是解除引用和.的捷径，所以如果你有指向您的结构的指针。所以：

ing *n = malloc(sizeof(ing));

n->quantity = 5;   // This is the same as 
(*n).quantity = 5; // this.

从最基本的意义上讲，要访问结构的成员，请执行以下操作：

ing n;
n.quanity = 5;

如果声明指向结构的指针，要访问结构的成员，请执行以下操作：

ing *n;
n = malloc(sizeof(ing));
n->quanity = 5;

"prod a; and I allocate a->n=malloc(n*sizeof(ing));. But when I try to access to a->n->name it gives me error"

如果你宣布这样的结构，那么它给你一个错误的原因是因为你试图尊重一些不是指针的东西。

a.n->name

是正确的。

修改
看到你的代码后，我看到你的问题是什么：

* here!->*/if((n[find_ing(n, a.n[i]->name, dim_n)].quantity)/(a.n->quantity)<max_prod)

问题是你做的比你想象的还要多。 [i]正在进行添加和取消引用，然后->正在执行另一个级别。

以下是它应该如何显示的快速示例：

prod a; a.n = malloc(3 * sizeof(ing)); // array of 3 ing structs a.n[1].quantity = 5; // access quanity member of ing struct 1

编辑2
这是有问题的一行：

* here!->*/if((n[find_ing(n, a.n[i]->name, dim_n)].quantity)/(a.n->quantity)<max_prod)

以下是应该做的事情：

if((n[find_ing(n, a.n[i].name, dim_n)].quantity)/(a.n->quantity)<max_prod)

编辑3
完全忽略了显而易见的事实。您将一个ing结构传递给此函数n：

int ret_max_producity(prod a, ing n, int dim_n) ^ | that's just a single struct totally different than the n that's passed in as a member in the `a` struct

然后在你的if检查中你试图以数组的形式访问这个结构：

n[find_ing(n, a.n[i]->name, dim_n)].quantity

不 ing变量中包含n个结构数组，您只有一个ing变量。因此，对于将这个单一结构视为结构数组而言，你大吼大叫。

指向结构内部结构的指针;如何访问没有错误？

2 个答案: