Partager via

Structures et classes (Visual Basic)

Visual Basic unifie la syntaxe des structures et des classes, avec le résultat que les deux entités prennent en charge la plupart des mêmes fonctionnalités. Toutefois, il existe également des différences importantes entre les structures et les classes.

Les classes ont l’avantage d’être des types de référence : la transmission d’une référence est plus efficace que la transmission d’une variable de structure avec toutes ses données. En revanche, les structures ne nécessitent pas d’allocation de mémoire sur le tas global.

Comme vous ne pouvez pas hériter d’une structure, les structures doivent être utilisées uniquement pour les objets qui n’ont pas besoin d’être étendus. Utilisez des structures lorsque l’objet que vous souhaitez créer a une petite taille d’instance et prenez en compte les caractéristiques de performances des classes et des structures.

Similitudes

Les structures et les classes sont similaires à ce qui suit :

  • Les deux sont des types de conteneurs , ce qui signifie qu’ils contiennent d’autres types en tant que membres.

  • Les deux ont des membres, qui peuvent inclure des constructeurs, des méthodes, des propriétés, des champs, des constantes, des énumérations, des événements et des gestionnaires d’événements.

  • Les membres des deux peuvent avoir des niveaux d’accès individualisés. Par exemple, un membre peut être déclaré Public et un autre Private.

  • Les deux peuvent implémenter des interfaces.

  • Les deux peuvent avoir des constructeurs partagés, avec ou sans paramètres.

  • Les deux peuvent exposer une propriété par défaut, à condition que cette propriété accepte au moins un paramètre.

  • Les deux peuvent déclarer et déclencher des événements, et les deux peuvent déclarer des délégués.

Différences

Les structures et les classes diffèrent dans les particularités suivantes :

  • Les structures sont des types valeur ; les classes sont des types de référence. Une variable d’un type de structure contient les données de la structure, plutôt que de contenir une référence aux données en tant que type de classe.

  • Les structures utilisent l’allocation de pile ; les classes utilisent l’allocation de tas.

  • Tous les éléments de structure sont Public par défaut ; les variables de classe et les constantes sont Private par défaut, tandis que d’autres membres de classe sont Public par défaut. Ce comportement pour les membres de classe assure la compatibilité avec le système Visual Basic 6.0 des valeurs par défaut.

  • Une structure doit avoir au moins une variable non partagée ou un élément d’événement non partagé, non personnalisé ; une classe peut être complètement vide.

  • Les éléments de structure ne peuvent pas être déclarés en tant que Protected; les membres de classe peuvent.

  • Une procédure de structure peut gérer les événements uniquement s’il s’agit d’une procédure partagéeSub , et uniquement par le biais de l’instruction AddHandler ; toute procédure de classe peut gérer des événements, à l’aide du mot clé Handles ou de l’instruction AddHandler . Pour plus d’informations, consultez Événements.

  • Les déclarations de variable de structure ne peuvent pas spécifier d’initialiseurs ou de tailles initiales pour les tableaux ; Les déclarations de variables de classe peuvent.

  • Les structures héritent implicitement de la System.ValueType classe et ne peuvent pas hériter d’un autre type ; les classes peuvent hériter d’une classe ou d’une classe autre que System.ValueType.

  • Les structures ne peuvent pas être héritées ; les classes sont.

  • Les structures ne sont jamais arrêtées. Par conséquent, le Common Language Runtime (CLR) n’appelle jamais la Finalize méthode sur une structure ; les classes sont arrêtées par le garbage collector (GC), qui appelle Finalize une classe lorsqu’elle détecte qu’il n’y a pas de références actives restantes.

  • Une structure ne nécessite pas de constructeur ; une classe en nécessite un.

  • Les structures peuvent avoir des constructeurs non partagés uniquement s’ils prennent des paramètres ; les classes peuvent les avoir avec ou sans paramètres.

Chaque structure a un constructeur public implicite sans paramètres. Ce constructeur initialise tous les éléments de données de la structure à leurs valeurs par défaut. Vous ne pouvez pas redéfinir ce comportement.

Instances et variables

Étant donné que les structures sont des types valeur, chaque variable de structure est liée définitivement à une instance de structure individuelle. Toutefois, les classes sont des types de référence et une variable objet peut faire référence à différentes instances de classe à différents moments. Cette distinction affecte votre utilisation des structures et classes de la manière suivante :

  • Initialisation. Une variable de structure inclut implicitement une initialisation des éléments à l’aide du constructeur sans paramètre de la structure. Par conséquent, Dim s As struct1 équivaut à Dim s As struct1 = New struct1().

  • Affectation de variables. Lorsque vous affectez une variable de structure à une autre ou transmettez une instance de structure à un argument de procédure, les valeurs actuelles de tous les éléments de variable sont copiées dans la nouvelle structure. Lorsque vous affectez une variable objet à une autre ou que vous transmettez une variable objet à une procédure, seul le pointeur de référence est copié.

  • Aucune affectation. Vous pouvez affecter la valeur Nothing à une variable de structure, mais l’instance continue d’être associée à la variable. Vous pouvez toujours appeler ses méthodes et accéder à ses éléments de données, bien que les éléments variables soient réinitialisés par l’affectation.

    En revanche, si vous définissez une variable Nothingd’objet sur , vous la dissociez de n’importe quelle instance de classe et vous ne pouvez pas accéder à des membres via la variable tant que vous n’avez pas affecté une autre instance.

  • Instances multiples. Une variable objet peut avoir différentes instances de classe qui lui sont affectées à des moments différents, et plusieurs variables d’objet peuvent faire référence à la même instance de classe en même temps. Les modifications que vous apportez aux valeurs des membres de classe affectent ces membres lorsqu’ils sont accessibles via une autre variable pointant vers la même instance.

    Toutefois, les éléments de structure sont isolés dans leur propre instance. Les modifications apportées à leurs valeurs ne sont pas reflétées dans d’autres variables de structure, même dans d’autres instances de la même Structure déclaration.

  • Égalité. Les tests d’égalité de deux structures doivent être effectués avec un test d’élément par élément. Deux variables d’objet peuvent être comparées à l’aide de la Equals méthode. Equals indique si les deux variables pointent vers la même instance.

Voir aussi