structure vs classe en langue rapide

From Apple book “L’une des différences les plus importantes entre les structures et les classes est que les structures sont toujours copiées lorsqu’elles sont transmises dans votre code, mais les classes sont transmises par référence.”

Quelqu’un peut-il me laisser comprendre ce que cela signifie, pour moi la classe et la structure semblent être les mêmes.

Voici un exemple avec une class . Notez que lorsque le nom est modifié, l’instance référencée par les deux variables est mise à jour. Bob est maintenant Sue , partout où Bob a été référencé.

 class SomeClass { var name: Ssortingng init(name: Ssortingng) { self.name = name } } var aClass = SomeClass(name: "Bob") var bClass = aClass // aClass and bClass now reference the same instance! bClass.name = "Sue" println(aClass.name) // "Sue" println(bClass.name) // "Sue" 

Et maintenant, avec une struct nous voyons que les valeurs sont copiées et que chaque variable conserve son propre ensemble de valeurs. Lorsque nous définissons le nom sur Sue , la structure Bob dans aStruct n’est pas modifiée.

 struct SomeStruct { var name: Ssortingng init(name: Ssortingng) { self.name = name } } var aStruct = SomeStruct(name: "Bob") var bStruct = aStruct // aStruct and bStruct are two structs with the same value! bStruct.name = "Sue" println(aStruct.name) // "Bob" println(bStruct.name) // "Sue" 

Donc, pour représenter une entité complexe avec état, une class est géniale. Mais pour les valeurs qui sont simplement une mesure ou des bits de données connexes, une struct est plus logique, de sorte que vous pouvez facilement les copier et les calculer ou modifier les valeurs sans crainte d’effets secondaires.

Tant la classe que la structure peuvent faire:

  • Définir des propriétés pour stocker des valeurs
  • Définir des méthodes pour fournir des fonctionnalités
  • Être étendu
  • Conforme aux protocoles
  • Définir les initiateurs
  • Définir des indices pour donner access à leurs variables

Seule la classe peut faire:

  • Héritage
  • Type casting
  • Définir les désinitialiseurs
  • Autoriser le comptage de références pour plusieurs références.

struct sont des types de valeur. Cela signifie que si vous copiez l’instance de la structure dans une autre variable, elle est simplement copiée dans la variable.

Exemple de type de valeur

 struct Resolution { var width = 2 var height = 3 } let hd = Resolution(width: 1920, height: 1080) var cinema = hd //assigning struct instance to variable println("Width of cinema instance is \(cinema.width)")//result is 1920 println("Width of hd instance is \(hd.width)")//result is 1920 cinema.width = 2048 println("Width of cinema instance is \(cinema.width)")//result is 2048 println("Width of hd instance is \(hd.width)")//result is 1920 

Les classes sont des types de référence. Cela signifie que si vous affectez une instance de la classe à une variable, elle ne contiendra que la référence à l’instance et non la copie .

Différences majeures entre les structures et les classes:

  • Les structures ne peuvent pas hériter d’autres types.
  • Les classes utilisent le transtypage pour traiter une classe en tant que superclasse ou sous-classe, ainsi que pour vérifier l’adoption du protocole. Les structures ne peuvent utiliser que la partie adoption de protocole.
  • Les structures n’ont pas de désinitialiseurs.
  • Les structures ne peuvent pas avoir plusieurs références à la même instance

Si vous regardez plus loin dans le manuel Apple, vous verrez cette section: «Les structures et les énumérations sont des types de valeur»

Dans cette section, vous verrez ceci:

“Let hd = Résolution (largeur: 1920, hauteur: 1080) var cinema = hd Cet exemple déclare une constante appelée hd et la définit comme une résolution instance initialisée avec la largeur et la hauteur de la vidéo Full HD (1920 pixels de largeur par 1080 pixels de hauteur).

Il déclare ensuite une variable appelée cinema et la place à la valeur actuelle de hd. Comme Resolution est une structure, une copie de l’instance existante est créée et cette nouvelle copie est affectée à cinema. Même si le hd et le cinéma ont maintenant la même largeur et la même hauteur, ils sont deux instances complètement différentes dans les coulisses.

Ensuite, la propriété width de cinema est modifiée pour être la largeur de la norme 2K légèrement plus large utilisée pour la projection de cinéma numérique (2048 pixels de large et 1080 pixels de haut):

Cinema. Width = 2048 La vérification de la largeur de la propriété cinema indique qu’elle a bien changé pour être 2048:

Println (“cinema est maintenant (cinema. Width) pixels en largeur”) // imprime “cinema a 2048 pixels de largeur Cependant, la propriété width de l’occurrence hd d’origine a toujours l’ancien valeur de 1920:

println (“hd est toujours (hd. width) pixels en largeur”) // imprime “hd est toujours large de 1920 pixels”

Lorsque la valeur actuelle de hd a été atsortingbuée au cinéma, les valeurs stockées dans hd ont été copiées dans la nouvelle instance de cinéma. Le résultat final est deux instances complètement distinctes, qui contiennent juste les mêmes valeurs numériques. Étant donné qu’il s’agit d’instances distinctes, la définition de la largeur de cinéma sur 2048 n’affecte pas la largeur stockée dans HD.

Extrait de: Apple Inc. «Le langage de programmation rapide». IBooks. https://itun.es/us/jEUH0.l

C’est la plus grande différence entre les structures et les classes. Les structures sont copiées et les classes sont référencées.

Les réponses ci-dessus sont correctes. J’espère que ma réponse aidera quelqu’un qui ne comprend pas les réponses ci-dessus.

Bien dans Swift Il existe deux types d’objects

  1. Struct
  2. Classe

La principale différence entre eux est

  • Struct est un type de valeur
  • La classe est le type de référence

Par exemple ici code pour bien comprendre.

 struct SomeStruct { var a : Int; init(_ a : Int) { self.a = a } } class SomeClass { var a: Int; init(_ a: Int) { self.a = a } } var x = 11 var someStruct1 = SomeStruct(x) var someClass1 = SomeClass(x) var someStruct2 = someStruct1 var someClass2 = someClass1 someClass1.a = 12 someClass2.a // answer is 12 because it is referencing to class 1 property a someStruct1.a = 14 someStruct2.a // answer is 11 because it is just copying it not referencing it 

C’était la principale différence, mais nous avons également des différences.

Classe

  1. Doit déclarer l’initialisateur (constructeur)
  2. A des initialiseurs
  3. Peut hériter d’autres classes

Struct

  1. Il a un initialiseur gratuit pour vous, vous n’avez pas à déclarer initaliseur si l’initialiseur gratuit sera écrasé par votre initialiseur déclaré
  2. Ne pas avoir de désinitialisateur
  3. Ne peut pas hériter d’autres structures

Cette question semble être en double mais peu importe, les éléments suivants répondraient à la plupart des cas d’utilisation:

  1. L’une des différences les plus importantes entre les structures et les classes est que les structures sont des types de valeur et sont toujours copiées lorsqu’elles sont transmises dans votre code, et les classes sont des types de référence et sont transmises par référence.

  2. De plus, les classes ont l’inheritance qui permet à une classe d’hériter les caractéristiques d’un autre.

  3. Les propriétés Struct sont stockées sur Stack et les instances Class sont stockées sur Heap. Parfois, la stack est nettement plus rapide qu’une classe.

  4. Struct obtient automatiquement un initialiseur par défaut alors qu’en classe, nous devons initialiser.

  5. Struct est thread-safe ou singleton à tout moment.

Et aussi, Pour résumer la différence entre les structures et les classes, il est nécessaire de comprendre la différence entre les types valeur et référence.

  1. Lorsque vous faites une copie d’un type de valeur, il copie toutes les données de la chose que vous copiez dans la nouvelle variable. Ce sont 2 choses distinctes et changer l’une n’affecte pas l’autre.
  2. Lorsque vous effectuez une copie d’un type de référence, la nouvelle variable fait référence au même emplacement de mémoire que celui que vous copiez. Cela signifie que changer l’un changera l’autre car ils se réfèrent tous deux au même emplacement mémoire. L’exemple de code ci-dessous peut être pris comme référence.

// sampleplayground.playground

  class MyClass { var myName: Ssortingng init(myName: Ssortingng){ self.myName = myName; } } var myClassExistingName = MyClass(myName: "DILIP") var myClassNewName = myClassExistingName myClassNewName.myName = "John" print("Current Name: ",myClassExistingName.myName) print("Modified Name", myClassNewName.myName) print("*************************") struct myStruct { var programmeType: Ssortingng init(programmeType: Ssortingng){ self.programmeType = programmeType } } var myStructExistingValue = myStruct(programmeType: "Animation") var myStructNewValue = myStructExistingValue myStructNewValue.programmeType = "Thriller" print("myStructExistingValue: ", myStructExistingValue.programmeType) print("myStructNewValue: ", myStructNewValue.programmeType) 

Sortie:

 Current Name: John Modified Name John ************************* myStructExistingValue: Animation myStructNewValue: Thriller 

Habituellement (dans la plupart des langages de programmation), les objects sont des blocs de données stockés sur le tas, puis une référence (normalement un pointeur) à ces blocs contient un name utilisé pour accéder à ces blocs de données. Ce mécanisme permet de partager des objects dans le tas en copiant la valeur de leurs références (pointeurs). Ce n’est pas le cas des types de données de base tels que les entiers, car la mémoire nécessaire pour créer une référence est presque identique à celle de l’object (dans ce cas, la valeur entière). Ainsi, ils seront transmis en tant que valeurs et non en tant que référence dans le cas d’objects volumineux.

Swift utilise struct pour améliorer les performances, même avec les objects Ssortingng et Array.

Une très bonne lecture ici

Afin de comprendre la différence entre Struct et Class, nous devons connaître la principale différence entre les types valeur et référence. Les structures sont des types de valeur et cela signifie que chaque modification apscope modifiera simplement cette valeur. Les classes sont des types de référence et chaque modification d’un type de référence modifiera la valeur allouée à cet endroit de la mémoire ou de la référence. Par exemple:

Commençons par une classe, cette classe est conforme à Equatable juste pour pouvoir comparer des instances, nous créons une instance appelée pointClassInstanceA et une autre appelée pointClassInstanceB nous pointClassInstanceB classe A à la classe B, maintenant l’assertion dit qu’elles sont identiques …

 class PointClass: Equatable { var x: Double var y: Double init(x: Double, y: Double) { self.x = x self.y = y } static func == (lhs: PointClass, rhs: PointClass) -> Bool { return lhs.x == rhs.x && lhs.y == rhs.y } } var pointClassInstanceA = PointClass(x: 0, y: 0) var pointClassInstanceB = pointClassInstanceA assert(pointClassInstanceA==pointClassInstanceB) pointClassInstanceB.x = 10 print(pointClassInstanceA.x) //this prints 10 

Ok, que s’est-il passé ici? Si nous venons de changer la valeur x de pointsClassInstanceB, cela change également la valeur x de pointClassInstanceA? eh bien, cela montre comment les types de référence fonctionnent, quand on assigne l’instance A, en tant que valeur de l’instance B, puis on modifie X de l’un d’eux, cela changera les deux X parce qu’ils partagent la même référence et référence.

Faisons la même chose mais avec une structure

 struct PointStruct: Equatable { var x: Double var y: Double init(x: Double, y: Double) { self.x = x self.y = y } static func == (lhs: PointStruct, rhs: PointStruct) -> Bool { return lhs.x == rhs.x && lhs.y == rhs.y } } var pointStructInstanceA = PointStruct(x: 0, y: 0) var pointStructInstanceB = pointStructInstanceA assert(pointStructInstanceA==pointStructInstanceB) pointStructInstanceB.x = 100 print(pointStructInstanceA.x) //this will print 0 

Nous avons fondamentalement la même structure que notre classe, mais maintenant vous pouvez voir que lorsque vous imprimez la valeur x de pointStructInstanceA dans ce cas, cela n’a pas changé, et cela parce que les types de valeurs fonctionnent différemment et que chaque modification sur l’une de leurs instances sera ” indépendant “et n’affectera pas l’autre.

Swift suggère d’utiliser davantage de types de valeur et vous pouvez dire que leurs bibliothèques sont basées sur des structures pour éviter les problèmes que les types de référence apportent, comme modifier involontairement une valeur, etc. Les structures sont la voie à suivre sur Swift. J’espère que cela aide.

Voici un exemple qui montre la différence entre struct et class précisément.

capture d’écran du code écrit dans la cour de récréation
capture d'écran du code écrit dans la cour de récréation

 struct Radio1{ var name:Ssortingng // init(name:Ssortingng) { // self.name = name // } } struct Car1{ var radio:Radio1? var model:Ssortingng } var i1 = Car1(radio: Radio1(name:"murphy"),model:"sedan") var i2 = i1 //since car instance i1 is a struct and //this car has every member as struct , //all values are copied into i2 i2.radio?.name //murphy i2.radio = Radio1(name: "alpha") i2.radio?.name //alpha i1.radio?.name //murphy //since Radio1 was struct , //values were copied and thus // changing name of instance of Radio1 in i2 //did not bring change in i1 class Radio2{ var name:Ssortingng init(name:Ssortingng) { self.name = name } } struct Car2{ var radio:Radio2? var model:Ssortingng } var i3 = Car2(radio: Radio2(name:"murphy"),model:"sedan") //var radioInstance = Radio2(name: "murphy") //var i3 = Car2(radio: radioInstance,model:"sedan") var i4 = i3 //since i3 is instance of struct //everything is copied to i4 including reference of instance of Radio2 //because Radio2 is a class i4.radio?.name //murphy i4.radio?.name="alpha" i4.radio?.name //alpha i3.radio?.name //alpha //since Radio2 was class, //reference was copied and //thus changing name of instance //of Radio2 in i4 did bring change in i3 too //i4.radio?.name //i4.radio = Radio2(name: "alpha") //i4.radio?.name // //i3.radio?.name 

Alreday il y a beaucoup écrit à ce sujet, je voudrais y append une analogie. J’espère que vous n’aurez jamais de doute après cela: Bottom line: les classes sont passées par référence alors que les structs sont passées par valeur.

Supposons que vous partagiez une fiche Google avec votre ami. Maintenant, s’il change quelque chose à cela, vous verrez également que les modifications sur votre google doc, signifie que votre copie est également affectée. C’est fondamentalement ” passé par référence “.

Mais supposons que si vous avez un fichier .XLS enregistré dans votre machine. Vous fournissez ce fichier à votre ami. Maintenant, s’il effectue un changement dans ce fichier, votre fichier ne sera pas endommagé / modifié car vous avez votre propre copie. C’est fondamentalement ” passé par valeur “. Vous avez déjà plusieurs programmes simples pour vérifier cette analogie dans les terrains de jeux rapides.

 1.structure is value type. = > when we assign structure variable to other variable or pass as parameter to function, it creates separate/new copy => so that changes made on one variable does not reflect on another.[We can say like **call by value** concept] Example : struct DemoStruct { var value: Ssortingng init(inValue: Ssortingng) { self.value = inValue } } var aStruct = DemoStruct(inValue: "original") var bStruct = aStruct // aStruct and bStruct are two structs with the same value! but references to diff location`enter code here` bStruct.value = "modified" print(aStruct.value) // "original" print(bStruct.value) // "modified" 2.class is reference type. = > when we assign structure variable to other variable or pass as parameter to function, it **does not** creates separate/new copy => so that changes made on one variable does not reflect on another.[We can say like **call by reference** concept] Example: class DemoClass { var value: Ssortingng init(inValue: Ssortingng) { self.value = inValue } } var aClass = DemoClass(inName: "original") var bClass = aClass // aClass and bClass now reference the same instance! bClass.value = "modified" print(aClass.value) // "modified" print(bClass.value) // "modified"