Pointeur vers une struct à l'intérieur d'une structure (struct); Comment accéder sans erreurs?

Autant que je sache, si l'élément à l'intérieur d'une structure est un pointeur, vous l'appelez avec ->, si c'est une valeur normale, il est utilisé ..

ici mon typedefs:

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

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

puis-je déclarer un prod a; et je allouer a->n=malloc(n*sizeof(ing));.
Mais lorsque j'essaie d'accéder à a.n->name il me donne l'erreur.

Tous les 4 combinaisons me donne l'erreur "error: invalid argument de type de '->' (, 'de prod' (ou 'ing'))" ou "erreur: indice de la valeur n'est ni tableau, ni pointeur, ni vecteur".

Pourquoi?

    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);
}

Pointeur vers une struct à l'intérieur d'une structure (struct); Comment accéder sans erreurs?

Il serait intéressant de lire un tutoriel sur le C les opérateurs, ce qui est le plus certainement couvert dans n'importe quel débutant-niveau de langue tutoriel.
Ce n'est pas que si l'élément à l'INTÉRIEUR de la structure est un pointeur que vous utilisez -> c'est quand le symbole lui-MÊME est un pointeur de variable que vous utilisez '-> " Quand le symbole est de type struct foo puis vous utilisez un '.'

InformationsquelleAutor Lamberto Basti | 2013-05-10

c pointers struct typedef

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 ..

Non, le . opérateur est utilisé pour accéder aux membres d'une structure, la -> opérateur est une coupe courte pour déréférencer et ., de sorte que vous utilisez, si vous avez un pointeur de votre structure. Donc:
```
ing *n = malloc(sizeof(ing));

n->quantity = 5;   //This is the same as 
(*n).quantity = 5; //this.
```
Dans le sens le plus élémentaire, pour accéder à une structure de membres vous faites cela:
```
ing n;
n.quanity = 5;
```
D'accéder à la structure des membres si vous déclarez un pointeur de votre structure, vous effectuez cette opération:
```
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"

Si vous êtes à la déclaration d'une structure comme ça, alors, la raison c'est de vous donner une erreur est parce que vous essayez de déférence quelque chose qui n'est pas un pointeur.
```
a.n->name
```
serait correct.

MODIFIER

Après avoir vu ton code, je vois quel est ton problème:
```
* here!->*/if((n[find_ing(n, a.n[i]->name, dim_n)].quantity)/(a.n->quantity)<max_prod)
```
Le problème est que vous êtes en train de faire plus de déférence que vous ne le pensez. Le [i] est en train de faire un complément et de déréférencement puis le -> est en train de faire un autre niveau.

Voici un petit exemple de la façon dont il devrait ressembler à:
```
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
```
EDIT 2

Voici la ligne en question:
```
* here!->*/if((n[find_ing(n, a.n[i]->name, dim_n)].quantity)/(a.n->quantity)<max_prod)
```
Voici ce qu'elle aurait été:
```
if((n[find_ing(n, a.n[i].name, dim_n)].quantity)/(a.n->quantity)<max_prod)
```
MODIFIER 3

Totalement négligé l'évidence. Vous êtes le passage d'un seul ing struct à cette fonction appelée 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
```
Mais alors, à votre vérifier si vous essayez d'accéder à cette structure comme un tableau:
```
n[find_ing(n, a.n[i]->name, dim_n)].quantity
```
Vous ne pas disposez d'un tableau de ing structures dans le n variable, vous n'avez qu'une seule ing variable. Il est donc crier à vous pour le traitement de cette unique structure comme un tableau de structures.
- ici vous pouvez voir de quoi je parle... je ne sais pas quoi faire. Chaque combinaison me donne une erreur (Edit: une image est un doublon, mais encore me donne l'erreur)....
- er.. non, vous n'avez pas fait toutes les combinaisons, vous avez manqué l'un qui fonctionne. 😉 Voir EDIT2 dans ma réponse. Que vous avez à faire a.n[i].name parce que vous êtes à l'aide de la [] indice, mais vous utilisez a.n->quanity car il n'y a pas de [] indice là. Got it?
- Je vous dois une pizza pour la patience 🙂 d'ailleurs, il me donnent encore erreur
- OK, j'ai raté la chose la plus évidente au sujet de votre code. Voir modifier 3. Le problème, c'est que vous n'avez pas un tableau, là, vous avez passé une structure unique n de type ing à votre fonction et vous essayez d'accéder à l' [] comme si c'était un tableau. Vous ont et le tableau nommé n dans le a variable, mais la n que vous avez passé à la fonction est différente et n'est pas un tableau. 🙂 Puis-je vous suggérer quelques noms descriptifs pour les variables? Il aurait aidé à trouver plus rapidement.
- Enfin c'est résolu! Je vous remercie vraiment! My bad, je suis à la programmation depuis 10 heures de commutation beetwin C et le montage! J'ai besoin d'une pause 🙂
- Vous pouvez faire une pause et me ça la pizza que vous me devez. 😉 Heureux de vous aider!
InformationsquelleAutor Mike
4

Si vous déclarez une prod un, et pas une prod * un, alors vous avez besoin pour accéder à la membres par un.n. Puisque n est un pointeur, il devrait être un.n->nom.

-> n'est utilisé que si vous avez un pointeur vers une structure. . est utilisé lorsque vous avez une instance d'une structure.

prod a;

un.n = malloc(sizeof(ing *)); //Pourquoi êtes-vous en multipliant ce nombre par n? ne pas le faire.
un.n = adresse de l'instance de ing que vous avez fait. un.n = &ing structure.

un.n->tout ce que = vous pouvez Maintenant accéder à Cette valeur

Edit:

Se débarrasser du type defs. Il faut lire
```
struct Foo{

members
};

struct Foo2{
members
};
```
Il devrait être bon. Vous êtes à l'aide de typedef dans le mauvais sens je crois.
```
struct ing
{
    char name[50];
    int quantity;
};

struct prod
{
    char name[50];
    ing *n;
    int price, n_ing, max_producity;
};
```
Vous avez aussi besoin de transmettre, il int adresses de ces deux structures, et ensuite obtenir un pointeur en dehors d'eux. Si votre déclaration de fonction doit se lire:
```
int ret_max_producity(prod * a, ing  *n, int dim_n)
```
et lors de l'appel de ret_max_productivity, il devraient avoir:
```
ret_max_productivity(&a, &n, int dim_n);
```
- ouais, il me donne toujours une erreur....
- j'ai besoin d'un vecteur d'ing à l'intérieur de prod, sinon je l'aurais déclarer normalement! J'ai peur qu'elle me donne toujours l'erreur! Je vais à lier la fonction, je suis en train de travailler sur
- Je vois votre problème, signalé dans ma réponse ci-dessous. Par ailleurs, en C, il ne s'appelle pas un vecteur, il est appelé un tableau.
InformationsquelleAutor Magn3s1um

Vous devez vous connecter pour publier un commentaire.