Utilisation des syndicats avec des structures

Question

j'ai une structure comme ceci:

struct data 
{ 
    char abc[10]; 
    int cnt; 
    struct data *next, *prior; 
}; 
struct data *start, *last; 
struct data *start1, *last1; 
struct data *start2, *last2; 

L'entier 'cnt' peut avoir deux valeurs. Les pointeurs:

struct data *start, *last; 

sont utilisés pour relier toutes les données avec toutes les valeurs de « cnt ». Les pointeurs:

struct data *start1, *last1; 
struct data *start2, *last2; 

sont utilisés pour relier les données lorsque la valeur de « cnt » est 1 ou 2. Mon problème est que lorsque je change la valeur de « abc » ou « cnt » pour une liste chaînée, disons 'start-> abc', les valeurs 'start1-> abc' et 'start2-> abc' sont inchangées car elles résident dans des emplacements mémoire différents.
Je voudrais qu'un changement de données sous une liste soit reflété dans les deux autres listes. Je crois que les 'syndicats' pourraient m'aider à le faire mais je ne sais pas comment le mettre en place.

Toute aide appréciée!

Answer 1

Non, impossible à faire.

Si même vous trouvez une solution qui utilise des syndicats pour ce faire, vous aurez essentiellement data objets alloués de telle sorte qu'ils se chevauchent en mémoire. Vous finiriez avec un bloc de mémoire contigu.

Au lieu de cela, ne pas tenir compte de la liste liée tout à fait et utiliser un tableau: (. Ne pas sortir des limites)

struct data { 
    char abc[10]; 
    int data; 
} 

struct data datas[50]; 
struct data* some = datas[20]; 
struct data* prev = some - 1; 
struct data* next = some + 1; 

---

Si vous voulez vraiment une liste chaînée pour Pour une raison quelconque, le but de chacun est que chaque élément peut être n'importe où dans la mémoire. Cela signifie que chaque élément doit se souvenir de l'adresse du suivant et du précédent afin de permettre une navigation dans les deux sens. Par conséquent, plutôt que de penser à des astuces de syndication, créez simplement une fonction insertData ou removeData qui effectue des opérations de base sur une liste et corrige également tous les pointeurs dans les éléments voisins.

Answer 2

Si vous voulez que le data vive simultanément sur deux listes, la liste «tous» et la liste «cnt», vous avez besoin de deux ensembles de pointeurs start, last dans la structure.

struct data 
{ 
    char abc[10]; 
    int cnt; 
    struct data *next_all, *prior_all; 
    struct data *next_cnt, *prior_cnt; 
}; 

Lorsque vous modifiez la valeur de cnt, vous devez supprimer les données de la liste next_cnt, prior_cnt (correspondant à start1, last1 ou start2, last2) et l'ajouter à l'autre.

Answer 3

char global_abc[10]; 
int global_cnt; 

struct data 
{ 
    char *abc; 
    int *cnt; 
    struct data *next, *prior; 
}; 

start->abc = start1->abc = start2->abc = global_abc; 
start->cnt = start1->cnt = start2->cnt = aglobal_cnt; 

Et maintenant, quand vous avez modifié le

strcpy(start->abc, "any"); 

alors il sera changé pour les autres éléments.

Et quand vous avez modifié le

*(start->cnt) = 5; 

alors il sera changé pour les autres éléments.

Answer 4

Utilisez un ensemble de tableaux pour stocker les données et utilisez un pointeur vers les tableaux de vos structures. Ensuite, les entrées « liées » peuvent pointer vers la même mémoire tampon de données ...

struct data 
{ 
    char* abc; 
    int cnt; 
    struct data *next, *prior; 
}; 
struct data *start, *last; 
struct data *start1, *last1; 
struct data *start2, *last2; 

char abcBuffer[2][10]; 

et une fonction quelque part ...

start->abc = abcBuffer[start->cnt]; 
start1->abc = abcBuffer[start1->cnt]; 
start2->abc = abcBuffer[start2->cnt]; 

Dans ce cas, la modification du contenu de abcBuffer[n] reflète la même changer à travers toutes les structures liées à ce tampon. La clé, cependant, est que vous ne pouvez pas le faire en utilisant une structure «partagée» telle qu'une union, mais devez la gérer dans votre code.