“erreur: l'affectation à l'expression de la matrice de type error” quand je assigner une structure de champ (C)

Je suis un débutant programmeur C, hier, j'ai appris l'utilisation des structures et de l'application éventuelle de ceux-ci au sujet de la résolution de problèmes spécifiques. Cependant, quand je faisais des expériences avec mon C IDE (Codeblocks 16.01) afin d'en apprendre cet aspect de la programmation en C, j'ai rencontré un étrange problème. Le code est le suivant:

#include <stdio.h>

#define N 30

typedef struct{
     char name[N];
     char surname[N];
     int age;
} data;

int main() {
     data s1;
     s1.name="Paolo";
     s1.surname = "Rossi";
     s1.age = 19;
     getchar();
     return 0;
}

Lors de la compilation, le compilateur (GCC 4.9.3-1 sous Windows) m'a confié une erreur qui dit que

"erreur: affectation à l'expression avec l'ensemble erreur de type"

sur instruction

s1.name="Paolo" 
s1.surname="Rossi"

alors que si je ne

data s1 = {"Paolo", "Rossi", 19};

il fonctionne.
Ce que je fais mal?

Vous avez découvert l'une des différences entre la cession et de l'initialisation.
Pouvez-vous être plus précis? merci 😉
Vous pouvez écrire s1 = (const data){"Paolo", "Rossi", 19};

InformationsquelleAutor Chief096 | 2016-05-14

38

Vous êtes confrontés problème dans
```
 s1.name="Paolo";
```
parce que, dans le membre de GAUCHE, vous êtes à l'aide d'un tableau type, ce qui n'est pas assignables.

D'élaborer, à partir de C11, chapitre §6.5.16

opérateur d'affectation doit avoir une modifiables lvalue que son opérande de gauche.

et, s'agissant de la modifiables lvalue, à partir du chapitre §6.3.2.1

Modifiable lvalue est une lvalue que
n'a pas de type tableau, [...]

Vous devez utiliser strcpy() à copier dans le tableau.

Cela dit, data s1 = {"Paolo", "Rossi", 19}; fonctionne très bien, parce que ce n'est pas un direct affectation impliquant la cession de l'opérateur. Là, nous sommes à l'aide d'un corset-joint une liste d'initialiseur de fournir les valeurs initiales de l' objet. Qui suit la loi de l'initialisation, comme mentionné dans le chapitre §6.7.9

Chaque accolade-joint une liste d'initialiseur est associé à un objet courant. Lorsque aucune
les désignations sont présents, les sous-objets de l'objet courant sont initialisés dans l'ordre de l'
le type de l'objet courant: les éléments du tableau dans l'augmentation de l'indice de l'ordre, de la structure
les membres en ordre de déclaration, et le premier nommé membre d'un syndicat.[....]
- Si j'ai char *b = "Hello" , et si j'ai char c[] = "hello" , les deux œuvres , si pour le premier cas, je ne b = "helloworld" , il travaille trop , mais pour le second cas, si je ne c = "helloworld" , il ne fait pas pourquoi ?
- c'est exactement ce qui est expliqué dans la réponse. Vous ne pouvez pas affecter à un tableau.
InformationsquelleAutor Sourav Ghosh
12

Veuillez vérifier cet exemple ici: Accéder Aux Membres De Structure

Il est expliqué que la bonne façon de le faire est comme ceci:
```
strcpy(s1.name , "Egzona");
printf( "Name : %s\n", s1.name);
```
- cela a une fonction supplémentaire d'appel, les frais généraux(dont les compilateurs peuvent choisir de l'inclure, mais n'ont généralement pas), qui fait une boucle plutôt que dans la ligne, et cette boucle n'est pas éliminé si la machine que vous êtes compilation sur pouvez copier le tout en un seul mouvement, il le fait toujours au moins une itération. Cela semble comme il ne peut être résolu sans prétraitement le code source C de ne pas le faire pour vous. char x[2] = {'h', 0}; *(char (*)[2])&x = *(char (*)[2])&x; devrait être nettement plus rapide que strcpy(x, x, 2) s'il était valide C.
InformationsquelleAutor
8
```
typedef struct{
     char name[30];
     char surname[30];
     int age;
} data;
```
définit que data doit être un bloc de mémoire qui s'adapte à 60 caractères plus 4 pour le type int*
```
[----------------------------,------------------------------,----]
 ^ this is name              ^ this is surname              ^ this is age
```
Il alloue de la mémoire sur la pile.
```
data s1;
```
Affectations juste des copies des chiffres, parfois des pointeurs.

Cela échoue
```
s1.name = "Paulo";
```
parce que le compilateur sait que s1.name est le début d'une struct 64 octets de long, et "Paulo" est un char[] 6 octets de long (6 à cause de la fuite \0 dans les chaînes C)

Donc, essayez d'affecter un pointeur vers une chaîne de caractères dans une chaîne.

À la copie "Paulo" en la structure au point name et "Rossi" en la structure au point de surname.
```
memcpy(s1.name,    "Paulo", 6);
memcpy(s1.surname, "Rossi", 6);
s1.age = 1;
```
Vous vous retrouvez avec
```
[Paulo0----------------------,Rossi0-------------------------,0001]
```
strcpy fait la même chose, mais il sait à propos de \0 la résiliation n'a donc pas besoin de la longueur codé en dur.

Vous pouvez définir une structure qui points de des tableaux de char de n'importe quelle longueur.
```
typedef struct {
  char *name;
  char *surname;
  int age;
} data;
```
Cela va créer
```
[----,----,----]
```
Ce sera désormais le travail parce que vous êtes le remplissage de la structure avec des pointeurs.
```
s1.name = "Paulo";
s1.surname = "Rossi";
s1.age = 1;
```
Quelque chose comme cela
```
[---4,--10,---1]
```
Où 4 et 10 sont des pointeurs.

*N. B. les services de renseignements et de conseils pratiques peuvent être différentes tailles, les tailles 4 ci-dessus sont 32bit comme un exemple.

InformationsquelleAutor teknopaul

Vous devez vous connecter pour publier un commentaire.