Les classes sont des types de référence et les structures sont des types de valeurs.
Quand je dis que les classes sont des types de référence,
elles contiennent essentiellement l'adresse d'une variable d'instance.
Par exemple:
Class MyClass
{
Public Int DataMember; //By default, accessibility of class data members
//will be private. So I am making it as Public which
//can be accessed outside of the class.
}
Dans la méthode principale,
je peux créer une instance de cette classe en utilisant un nouvel opérateur qui alloue de la mémoire pour cette classe
et stocke l'adresse de base de celle-ci dans la variable de type MyClass (_myClassObject2).
Static Public void Main (string[] arg)
{
MyClass _myClassObject1 = new MyClass();
_myClassObject1.DataMember = 10;
MyClass _myClassObject2 = _myClassObject1;
_myClassObject2.DataMember=20;
}
Dans le programme ci-dessus, MyClass _myClassObject2 = _myClassObject1; indique que les deux variables de type MyClass
- myClassObject1
- myClassObject2
et pointera vers le même emplacement mémoire.
Il affecte fondamentalement le même emplacement de mémoire dans une autre variable du même type.
Donc, si des modifications que nous apportons à l'un des objets, tapez MyClass aura un effet sur un autre
puisque les deux pointent vers le même emplacement de mémoire.
"_myClassObject1.DataMember = 10;" sur cette ligne, les deux membres de données de l'objet contiendront la valeur de 10.
"_myClassObject2.DataMember = 20;" sur cette ligne, le membre de données de l'objet contient la valeur de 20.
Finalement, nous accédons aux membres de données d'un objet via des pointeurs.
Contrairement aux classes, les structures sont des types de valeur. Par exemple:
Structure MyStructure
{
Public Int DataMember; //By default, accessibility of Structure data
//members will be private. So I am making it as
//Public which can be accessed out side of the structure.
}
Static Public void Main (string[] arg)
{
MyStructure _myStructObject1 = new MyStructure();
_myStructObject1.DataMember = 10;
MyStructure _myStructObject2 = _myStructObject1;
_myStructObject2.DataMember = 20;
}
Dans le programme ci-dessus,
instanciation de l'objet de type MyStructure à l'aide d'un nouvel opérateur et
stockage de l'adresse dans la variable _myStructObject de type MyStructure et
affectation de la valeur 10 au membre de données de la structure à l'aide de "_myStructObject1.DataMember = 10".
Dans la ligne suivante,
je déclare une autre variable _myStructObject2 de type MyStructure et j'assigne _myStructObject1 à cela.
Ici, le compilateur .NET C # crée une autre copie de l'objet _myStructureObject1 et
affecte cet emplacement mémoire dans la variable MyStructure _myStructObject2.
Donc, quel que soit le changement que nous effectuons sur _myStructObject1, il n'aura jamais d'effet sur une autre variable _myStructObject2 de type MyStructrue.
C'est pourquoi nous disons que les structures sont des types de valeur.
Ainsi, la classe de base immédiate pour la classe est Object et la classe de base immédiate pour Structure est ValueType qui hérite de Object.
Les classes prendront en charge un héritage, contrairement aux structures.
Comment dit-on cela?
Et quelle est la raison derrière cela?
La réponse est Classes.
Il peut être abstrait, scellé, statique et partiel et ne peut pas être privé, protégé et protégé en interne.