Introduction aux types de données définis par l'utilisateur en C++

Le type de données défini par l'utilisateur en c++ est un type par lequel les données peuvent être représentées. Le type de données informera l'interprète de la manière dont le programmeur utilisera les données. Un type de données peut être prédéfini ou défini par l'utilisateur. Des exemples de types de données prédéfinis sont char, int, float, etc. Nous discuterons en détail des types de données définis par l'utilisateur.

Comme les langages de programmation permettent à l'utilisateur de créer ses propres types de données en fonction de ses besoins. Par conséquent, les types de données définis par l'utilisateur sont appelés types de données définis par l'utilisateur. Par exemple; tableaux, classe, structure, union, énumération, pointeur, etc. Ces types de données sont plus complexes que les types de données prédéfinis.

Commencez votre cours de développement de logiciel gratuit

Développement Web, langages de programmation, tests de logiciels et autres

Types de données définies par l'utilisateur en C++

Voici les types mentionnés ci-dessous :

1. Structure

Une structure est définie comme une collection de divers types d'informations connexes sous un même nom. La déclaration de structure forme un modèle et les variables des structures sont appelées membres. Tous les membres de la structure sont généralement liés. Le mot clé utilisé pour la structure est "struct".

Par exemple; une structure pour l'identité de l'étudiant ayant 'name', 'class', 'roll_number', 'address' comme membre peut être créée comme suit :

struct stud_id
{
char name[20];
int class;
int roll_number;
char address[30];
};

C'est ce qu'on appelle la déclaration de la structure et elle se termine par un point-virgule (;). La mémoire n'est pas allouée alors que la déclaration de structure est déléguée lors de la spécification de celle-ci. La définition de structure crée des variables de structure et leur alloue de l'espace de stockage. Les variables de structures peuvent être définies comme suit :

stud_id I1, I2;

Où I1, I2 sont les deux variables de stud_id. Après avoir défini la structure, ses membres sont accessibles à l'aide de l'opérateur point comme suit :

I1.roll_number accédera au numéro de rôle de I1

I2.class accédera à la classe de I2

Exemple :

struct stud_id
{
int class, roll_number;
};
int main()
{
struct stud_id entries[10];   // Create an array of structures
entries[0].class = 4;           // Access array members
entries[0].roll_number = 20;
cout <<entries[0].class << ", " << entries[0].roll_number;
return 0;
}

2. Tableau

Un tableau est défini comme une collection de données homogènes. Il doit être défini avant de l'utiliser pour le stockage d'informations. Le tableau peut être défini comme suit :

<datatype> <array_name><[size of array]>
int marks[10]

La déclaration ci-dessus définit un tableau de type entier nommé marques qui peut stocker les notes de 10 étudiants. Une fois le tableau créé, on peut accéder à n'importe quel élément d'un tableau en écrivant le nom d'un tableau suivi de son index. Par exemple; pour accéder au 5 ^ème élément de marques, la syntaxe est la suivante :

marks[5]

Il donnera les notes stockées au 5 ^ème emplacement d'un tableau. Un tableau peut être unidimensionnel, bidimensionnel ou multidimensionnel selon la spécification des éléments.

Exemple :

int main()
{
int marks[10];
marks[0] = 5;
marks[2] = -10;
cout<<marks[0], marks[2]);
return 0;
}

3. Syndicat

Tout comme les structures, l'union contient également des membres de différents types de données. La principale différence entre les deux est que l'union économise de la mémoire car les membres d'une union partagent la même zone de stockage, tandis que les membres de la structure se voient attribuer leur propre zone de stockage unique. Les unions sont déclarées avec le mot-clé « union » comme suit :

union employee
{
int id;
double salary;
char name[20];
}

La variable de l'union peut être définie comme :

union employee E;

Pour accéder aux membres du syndicat, l'opérateur point peut être utilisé comme suit :

E.salary;

4. Classe

Une classe est une caractéristique importante du langage de programmation orienté objet, tout comme C++. Une classe est définie comme un groupe d'objets avec les mêmes opérations et attributs. Il est déclaré à l'aide d'un mot-clé "classe". La syntaxe est la suivante :

class <classname>
{
private:
Data_members;
Member_functions;
public:
Data_members;
Member_functions;
};

Dans ce cas, les noms des membres de données doivent être différents des fonctions membres. Il existe deux spécificateurs d'accès pour les classes qui définissent la portée des membres d'une classe. Ceux-ci sont privés et publics. Le membre spécifié comme privé n'est accessible que par les fonctions membres de cette classe particulière uniquement. Cependant, les membres définis comme le public peuvent également être consultés de l'intérieur et de l'extérieur de la classe. Les membres sans spécificateur sont privés par défaut. Les objets appartenant à une classe sont appelés instances de la classe. La syntaxe pour créer un objet d'une classe est la suivante :

<classname> <objectname>

Exemple :

class kids
{
public:                //Access specifier
char name[10];   //Data members
int age;
void print()         //Member function
{
cout<<”name is:”<< name;
}
}
Int main
{
Kids k;                    //object of class kid is created as k
k.name=”Eash”;
k.print();
return 0;
}

5. Énumération

L'énumération est spécifiée à l'aide d'un mot-clé « enum ». Il est défini comme un ensemble de constantes entières nommées qui spécifient toutes les valeurs possibles qu'une variable de ce type peut avoir. Par exemple, l'énumération de la semaine peut avoir les noms des sept jours de la semaine comme indiqué ci-dessous :

Exemple :

enum week_days{sun, mon, tues, wed, thur, fri, sat};
int main()
{
enum week_days d;
d = mon;
cout << d;
return 0;
}

6. Pointeur

Un pointeur est ce genre de type de données défini par l'utilisateur qui crée des variables pour contenir l'adresse mémoire d'autres variables. Si une variable porte l'adresse d'une autre variable, on dit que la première variable est le pointeur d'une autre. La syntaxe pour la même chose est :

type *ptr_name;

Ici, type est n'importe quel type de données du pointeur et ptr_name est le nom du pointeur.

Exemple :

void main()
{
int a = 10;
int *p;   // pointer variable is declared
p = &a;  // data type of pointer ‘p’ and variable ‘a’ should be same
cout<<"Value at p = ",<<p); // the address of a variable is assigned to a pointer
cout<<"Value at variable a = “,<<a);
cout<<"Value at *p = ",<< *p);
}

7. Typedef

En utilisant le mot-clé "typedef", vous pouvez définir de nouveaux noms de types de données à ceux existants. Sa syntaxe est :

typedef <type> <newname>;
typedef float balance;

Lorsqu'un nouveau nom est créé pour float, c'est-à-dire en utilisant balance, nous pouvons déclarer n'importe quelle variable de type float.

L'utilisation d'un typedef peut rendre le code facile à lire et également facile à porter sur une nouvelle machine.

Exemple :

typedef  int score;
int main()
{
score s1, s2;
s1 = 80;
cout << " " << b1;
return 0;
}

Conclusion

C++ prend en charge différents types de types de données définis par l'utilisateur, comme indiqué ci-dessus. Il existe de nombreux autres types de données tels que les fonctions, les références, etc. Leur utilisation facilite grandement la programmation et nous aide également à regrouper différents types de données dans une seule variable.