0

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

这是我的typedef：

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

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

然后我声明 aprod a;并分配a->n=malloc(n*sizeof(ing));。但是当我尝试访问a.n->name它时，我会出错。

所有 4 种组合都给我错误“错误：'->' 的无效类型参数（有'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);
}

错误

4

2 回答 2

4

如果你声明了一个prod a，而不是一个prod * a，那么你需要通过an来访问成员因为n是一个指针，它应该是an->name。

-> 仅在您有指向结构的指针时使用。. 当你有一个结构的实例时使用。

产品a；

an = malloc(sizeof(ing *)); //你为什么要把这个数字乘以n？不要那样做。an = 您创建的 ing 实例的地址。an = &ing 结构。

an->whatever = 现在您可以访问此值

编辑：

摆脱类型定义。它应该读

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);
于 2013-05-10T17:35:23.747 回答
4

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变量。所以它对你大喊大叫，因为你把这个单一的结构当作一个结构数组。

于 2013-05-10T17:36:57.340 回答