'>

Autres types de données

Types de données définis (typedef)
C + + permet de définir nos propres types basés sur d'autres types de données existantes. Nous pouvons le faire en utilisant le mot-clé typedef, dont le format est le suivant:

new_type_name de existing_type typedef;

où existing_type est un type C + + et new_type_name fondamentale ou composé est le nom pour le nouveau type nous définissons. Par exemple:

1
 2
 3
 4


   

 typedef char C; typedef unsigned int WORD; typedef char * pChar; typedef char field [50];



Dans ce cas, nous avons défini quatre types de données: C, WORD, pchar et sur ​​le terrain en tant que char, unsigned int, char * et char [50] respectivement, que nous pourrions parfaitement utiliser dans des déclarations plus tard que tout autre type valide:

 1
 2
 3
 4


   

 C mychar, anotherchar, *ptc1; WORD myword; pChar ptc2; field name;



typedef ne crée pas de types différents. Il ne crée synonymes de types existants. Cela signifie que le type de persoMots peut être considéré comme Word ou unsigned int, puisque les deux sont en fait du même type.

typedef peut être utile de définir un alias pour un type qui est fréquemment utilisé dans un programme. Il est également utile de définir des types quand il est possible que nous devrons changer le type dans les versions ultérieures de notre programme, ou si un type que vous souhaitez utiliser a un nom qui est trop long ou confus.

Unions
Les syndicats permettent une même portion de mémoire pour être accessible en tant que différents types de données, car tous sont en fait le même emplacement en mémoire. Sa déclaration et l'utilisation est similaire à celui des structures mais sa fonctionnalité est totalement différente:

 union union_name {
   member_type1 member_name1;
   member_type2 member_name2;
   member_type3 member_name3;
   .
   .
 Object_names};


Tous les éléments de la Déclaration de l'Union occupent le même espace physique dans la mémoire. Sa taille est l'un des plus grand élément de la déclaration. Par exemple:

 1
 2
 3
 4
 5


   

 union mytypes_t { char c; int i; float f; } mytypes;



définit trois éléments:

 1
 2
 3


   

 mytypes.c mytypes.i mytypes.f



chacun avec un type de données différent. Depuis ils sont tous référence au même emplacement en mémoire, la modification d'un des éléments aura une incidence sur la valeur de chacun d'eux. Nous ne pouvons pas stocker des valeurs différentes dans les indépendantes les unes des autres.

L'une des utilisations d'un syndicat peut avoir est d'unir un type élémentaire avec un tableau ou structures d'éléments plus petits. Par exemple:

 1
 2
 3
 4
 5
 6
 7
 8


   

 union mix_t { long l; struct { short hi; short lo; } s; char c[4]; } mix;



définit trois noms qui nous permettent d'accéder au même groupe de 4 octets: mix.l, mix.s et mix.c et que nous pouvons utiliser en fonction de la façon dont nous voulons accéder à ces octets, comme s'il s'agissait d'un seul type long données, comme s'ils étaient deux éléments courts ou comme un ensemble d'éléments Char, respectivement. J'ai types mixtes, les tableaux et les structures de l'Union afin que vous puissiez voir les différentes façons dont nous pouvons accéder aux données. Pour un système little-endian (la plupart des plates-formes PC), cette union pourrait être représentée comme suit:


L'alignement et l'ordre des membres d'un syndicat dans la mémoire exacte est dépendant de la plateforme. Donc être conscient des problèmes de portabilité possible avec ce type d'utilisation.

Unions anonymes
En C + +, nous avons la possibilité de déclarer les syndicats anonymes. Si nous déclarons une union sans nom, le syndicat sera anonyme et nous serons en mesure d'accéder à ses membres directement par leurs noms de membres. Par exemple, regardez la différence entre ces deux déclarations de la structure:

Structure avec syndicale régulière     Structure avec union anonyme

 struct {
   omble titre [50];
   auteur char [50];
   union {
     flotter dollars;
     int yen;
   } Prix;
 } Livre;

   

 struct {
   omble titre [50];
   auteur char [50];
   union {
     flotter dollars;
     int yen;
   };
 } Livre;


La seule différence entre les deux morceaux de code est que dans le premier que nous avons donné un nom à l'union (prix) et dans le second nous n'avons pas. La différence se voit quand on accéder aux membres dollars et en yens d'un objet de ce type. Pour un objet du premier type, ce serait:

 1
 2


   

 book.price.dollars book.price.yen



alors que pour un objet du deuxième type, ce serait:

 1
 2


   

 book.dollars book.yen



Une fois de plus je vous rappelle que parce que c'est un syndicat et non une structure, les membres dollars et en yens occupent le même espace physique dans la mémoire de sorte qu'ils ne peuvent pas être utilisés pour stocker deux valeurs différentes en même temps. Vous pouvez définir une valeur pour le prix en dollars ou en yens, mais pas dans les deux.

Énumérations (enum)
Énumérations créer de nouveaux types de données pour contenir quelque chose de différent qui n'est pas limitée aux valeurs des types de données fondamentales peuvent prendre. Sa forme est la suivante:

 ENUM enumeration_name {
   valeur1,
   valeur2,
   value3,
   .
   .
 Object_names};


Par exemple, nous pourrions créer un nouveau type de variable appelée colors_t pour stocker les couleurs avec la déclaration suivante:



   

 enum colors_t {black, blue, green, cyan, red, purple, yellow, white};



Notez que nous n'avons pas inclure n'importe quel type de données fondamental dans la déclaration. Pour le dire d'une certaine manière, nous avons créé un tout nouveau type de données à partir de zéro sans qu'il soit fondé sur un autre type existant. Les valeurs possibles que les variables de ce nouveau type color_t peuvent prendre sont les nouvelles valeurs constantes comprises entre accolades. Par exemple, une fois l'énumération colors_t est déclarée, les expressions suivantes sont valables:

 1
 2
 3
 4


   

 colors_t mycolor; mycolor = blue; if (mycolor == green) mycolor = red;



Les énumérations sont de type compatible avec les variables numériques, de sorte que leurs constantes sont toujours affectées d'une valeur numérique entière en interne. Si elle n'est pas spécifiée, la valeur équivalent entier à la première valeur possible est équivalent à 0 et les suivantes suivent une progression +1. Ainsi, dans notre type colors_t de données que nous avons défini ci-dessus, noir serait équivalent à 0, le bleu serait équivalent à 1, vert à 2, et ainsi de suite.

Nous pouvons spécifier explicitement une valeur entière pour l'une des valeurs constantes que notre type énuméré peut prendre. Si la valeur constante qui le suit n'est pas donné une valeur entière, il est supposé automatiquement la même valeur que la précédente plus un. Par exemple:

 1
 2
 3


   

 enum months_t { january=1, february, march, april, may, june, july, august, september, october, november, december} y2k;



Dans ce cas, y2k variable de type énuméré months_t peut contenir l'une des 12 valeurs possibles allant de janvier à décembre et qui sont équivalentes à des valeurs comprises entre 1 et 12 (non compris entre 0 et 11, puisque nous avons fait janvier égal à 1) . 
Publié par Drupal Study