Les structures (partie II)

Pointeur sur une structure

Il est possible de créer des pointeurs sur une struct.

package main

import (  
    "fmt"
)

type Employee struct {  
    nom, prenom string
    age, salaire        int
}

func main() {  
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}
    fmt.Println("nom:", (*emp8).nom)
    fmt.Println("Age:", (*emp8).age)
}

Dans le programme ci-dessus, emp8 est un pointeur sur la structure Employee. (*emp8).nom est le syntaxe pour accéder au champ nom de la structure emp8. La sortie du programme est:

Nom: Sam  
Age: 55 

**Le langage nous donne l'option d'utiliser emp8.nom au lieu de la déférence (*emp8).nom pour accéder au champ nom **.

package main

import (  
    "fmt"
)

type Employee struct {  
    nom, prenom string
    age, salaire         int
}

func main() {  
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}
    fmt.Println("nom:", emp8.nom)
    fmt.Println("Age:", emp8.age)
}

La sortie du programme est:

Nom: Sam  
Age: 55

Les champs anonymes

Le fragment de code ci-dessus crée une structure Personne qui a deux champs anonymes string et int.

type Personne struct {  
    string
    int
}

On va écrire un programme en utilisant les champs anonymes:

package main

import (  
    "fmt"
)

type Personne struct {  
    string
    int
}

func main() {  
    p := Personne{"Naveen", 50}
    fmt.Println(p)
}

Dans le programme ci-dessus, Personne est une structure qui a deux champs anonymes. p := Person{"Naveen", 50} définie une variable de type Personne. La sortie du programme est {Naveen 50}.

Bien que les champs anonymes n'ont pas de noms, le champ anonyme est le type d'un champ anonyme.

Exemple:

package main

import (  
    "fmt"
)

type Personne struct {  
    string
    int
}

func main() {  
    var p1 Personne
    p1.string = "naveen"
    p1.int = 50
    fmt.Println(p1)
}

Dans le programme ci-dessus, on a accès aux champs anonymes de Personne en utilisant leurs types qui sont respectivement string et int. La sortie du programme est:

{naveen 50}

Les structures imbriquées

Il est possible qu'une structure contienne un champ qui est lui même une structure, ce type de structure s'appelle une structure imbriquée.

package main

import (  
    "fmt"
)

type Adresse struct {  
    ville, etat string
}
type Personne struct {  
    nom string
    age int
    adresse Adresse
}

func main() {  
    var p Persone
    p.nom = "Naveen"
    p.age = 50
    p.adresse = Adresse {
        ville: "Chicago",
        etat: "Illinois",
    }
    fmt.Println("Nom:", p.nom)
    fmt.Println("Age:",p.age)
    fmt.Println("Ville:",p.adresse.ville)
    fmt.Println("Etat:",p.adresse.etat)
}

La sortie du programme est:

Nom: Naveen  
Age: 50  
Ville: Chicago  
Etat: Illinois  

Les champs supportés

Les champs qui appartiennent à une structure anonyme sont appelés des champs supportés "promoted " puisqu'on peut avoir l'accès à ces champs comme s'ils appartiennent à la structure qui contient le champ anonyme.

type Adresse struct {  
    ville, etat string
}
type Personne struct {  
    nom string
    age  int
    Adresse
}

Dans le programme ci-dessus, la structure Personne a un champ anonyme Adresse qui est de type struct. Maintenant, les champs de la structure Adresse qui sont ville et etat sont appelés des champs supportés "promoted" car on a l'accès à ces champs comme s'ils sont des champs de la structure Personne.

package main

import (  
    "fmt"
)

type Adresse struct {  
    ville, etat string
}
type Personne struct {  
    nom string
    age  int
    Adresse
}

func main() {  
    var p Personne
    p.nom = "Naveen"
    p.age = 50
    p.Adresse = Adresse{
        ville:  "Chicago",
        etat: "Illinois",
    }
    fmt.Println("Nom:", p.nom)
    fmt.Println("Age:", p.age)
    fmt.Println("Ville:", p.ville) 
    fmt.Println("Etat:", p.etat) 
}

La sortie du programme est:

Nom: Naveen  
Age: 50  
Ville: Chicago  
Etat: Illinois 

Les structures et les champs exportés

Si un type struct commence par une majuscule, alors il est un type exporté et on peut avoir l'accès à ce champ depuis d'autres packages. Identiquement si les champs d'une structure commencent par une majuscule, on peut avoir l'accès à ces champs depuis d'autres packages.

On va créer un programme qui a des packages personnalisés pour mieux comprendre ce qu'on vient de dire.

On crée un dossier structs dans le répertoire src dans le workspace de go. On crée un autre répertoire computer dans structs.

Dans le répertoire computer, on sauvegarde le programme ci-dessus avec le nom de fichier spec.go.

package computer

type Spec struct { // struct exporté
    Maker string //champ exporté
    model string //champ non exporté
    Price int //champ exporté
}

On va importer ce package du package main et utiliser la structure Spec.

On crée un fichier appelé main.go dans le répertoire structs et on écrit le programme suivant dans main.go.

package main

import "structs/computer"  
import "fmt"

func main() {  
    var spec computer.Spec
    spec.Maker = "apple"
    spec.Price = 50000
    fmt.Println("Spec:", spec)
}

La structure du package serait:

src  
   structs
          computer
                  spec.go
          main.go

La sortie du programme ci-dessus est: Spec: {apple 50000}.

Il n'est pas possible d'avoir l'accès au champ non exporté model.

package main

import "structs/computer"  
import "fmt"

func main() {  
    var spec computer.Spec
    spec.Maker = "apple"
    spec.Price = 50000
    spec.model = "Mac Mini"
    fmt.Println("Spec:", spec)
}

Après l'exécution du programme, le compilateur va lancer une erreur spec.model undefined (cannot refer to unexported field or method model).

L'égalité des structures

Les structures sont des types de valeurs qui sont comparables si leurs champs sont comparables. Si les champs de deux structures sont égaux, alors les champs correspondant sont égaux.

package main

import (  
    "fmt"
)

type name struct {  
    nom string
    prenom string
}


func main() {  
    nom1 := nom{"Jobs", "Steve"}
    nom2 := nom{"Jobs", "Steve"}
    if nom1 == nom2 {
        fmt.Println("nom1 et nom2 sont egaux")
    } else {
        fmt.Println("nom1 et nom2 ne sont pas egaux")
    }

    nom3 := name{no:"Jobs", lastName:"Jobs"}
    nom4 := name{}
    nom4.nom = "Jobs"
    if nom3 == name4 {
        fmt.Println("nom3 et nom4 sont egaux")
    } else {
        fmt.Println("nom3 et nom4 ne sont pas egaux")
    }
}

La sortie du programme est:

nom1 et nom2 sont égaux 
nom3 et nom4 ne sont pas egaux 

Les variables de structure ne sont pas comparables si elles ne contiennent pas des champs qui sont comparables.

---

Posted on Utopian.io - Rewarding Open Source Contributors

---