La fonction new()

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 22 sur 107.

Go fournit une fonction intégrée appelée new() qui alloue de la mémoire pour un type et retourne un pointeur vers celui-ci. La mémoire allouée est initialisée à la valeur zéro du type.

p := new(int)      // alloue de la mémoire pour un int
fmt.Println(*p)    // 0 (valeur par défaut)
fmt.Println(p)     // 0xc000018030 (adresse mémoire)

La fonction new() prend un type comme argument et retourne un pointeur vers une valeur zéro nouvellement allouée de ce type. Ceci est particulièrement utile lorsque vous avez besoin d'un pointeur mais que vous n'avez pas de variable existante à référencer.

Avec les structures, new() crée un pointeur vers une structure dont tous les champs sont initialisés à leur valeur zéro.

type Person struct {
    Name string
    Age  int
}

p := new(Person)
fmt.Println(p.Name)  // "" (chaîne vide)
fmt.Println(p.Age)   // 0

Vous pourriez vous demander quand utiliser new() par rapport à l'opérateur d'adresse &. Les deux approches ci-dessous sont équivalentes :

// Utilisation de new()
p1 := new(Person)

// Utilisation de l'opérateur d'adresse avec un littéral
p2 := &Person{}

La syntaxe &Person{} est plus courante en pratique car elle vous permet d'initialiser les champs en même temps. Utilisez new() lorsque vous voulez spécifiquement une instance avec des valeurs par défaut (zero-valued) et que vous préférez une sémantique d'allocation de mémoire explicite.

Défi

Facile

Construisons un gestionnaire de configuration qui démontre comment new() alloue de la mémoire et initialise les structs à leurs valeurs par défaut (zero values). Vous verrez comment cette approche diffère de l'utilisation de l'opérateur d'adresse avec un littéral de struct.

Vous organiserez votre code sur deux fichiers :

config.go : Définissez une struct ServerConfig avec les champs Host (string), Port (int), MaxConnections (int) et DebugMode (bool). Créez deux fonctions :
- NewServerConfig qui utilise new() pour allouer un ServerConfig et retourne directement le pointeur (avec toutes les valeurs par défaut).
- ConfigureServer qui prend un pointeur *ServerConfig ainsi qu'une chaîne host et un entier port, puis définit ces champs sur la configuration via le pointeur.
Ajoutez également une méthode Display sur *ServerConfig qui retourne une chaîne formatée affichant toutes les valeurs de configuration.
main.go : Lisez un hôte et un port depuis l'entrée. Tout d'abord, créez une configuration en utilisant NewServerConfig() et affichez-la pour montrer les valeurs par défaut. Ensuite, utilisez ConfigureServer pour définir l'hôte et le port, et affichez à nouveau la configuration pour montrer les valeurs mises à jour.

Les entrées suivantes seront fournies :

Ligne 1 : Nom de l'hôte (string)
Ligne 2 : Numéro de port (integer)

Votre méthode Display doit retourner une chaîne dans ce format exact :

Host: [Host]
Port: [Port]
MaxConnections: [MaxConnections]
DebugMode: [DebugMode]

Affichez la sortie de display deux fois — une fois avant la configuration (montrant les valeurs par défaut) et une fois après la configuration (montrant l'hôte et le port mis à jour).

Par exemple, avec localhost et 8080, votre sortie devrait être :

Host: 
Port: 0
MaxConnections: 0
DebugMode: false
Host: localhost
Port: 8080
MaxConnections: 0
DebugMode: false

Remarquez comment le premier affichage montre toutes les valeurs par défaut (chaîne vide, 0, 0, false) parce que new() initialise tout aux valeurs par défaut. Après l'appel à ConfigureServer, seuls l'hôte et le port changent tandis que les autres champs restent à leurs valeurs par défaut.

Aide-mémoire

La fonction new() alloue de la mémoire pour un type et renvoie un pointeur vers celui-ci, initialisé à la valeur zéro du type :

p := new(int)      // alloue de la mémoire pour un int
fmt.Println(*p)    // 0 (valeur zéro)
fmt.Println(p)     // 0xc000018030 (adresse mémoire)

Avec les structs, new() crée un pointeur vers une struct dont tous les champs sont définis sur leurs valeurs zéro :

type Person struct {
    Name string
    Age  int
}

p := new(Person)
fmt.Println(p.Name)  // "" (chaîne vide)
fmt.Println(p.Age)   // 0

Utiliser new() par rapport à l'opérateur d'adresse & - les deux sont équivalents :

// Utilisation de new()
p1 := new(Person)

// Utilisation de l'opérateur d'adresse avec un littéral
p2 := &Person{}

La syntaxe &Person{} est plus courante car elle permet l'initialisation des champs au moment de la création. Utilisez new() lorsque vous voulez une instance à valeur zéro avec une sémantique d'allocation de mémoire explicite.

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	// Lire l'entrée
	var host string
	var port int
	fmt.Scanln(&host)
	fmt.Scanln(&port)

	// TODO: Créer une configuration en utilisant NewServerConfig() et l'afficher
	// Cela montrera les valeurs par défaut (zero values)

	// TODO: Utiliser ConfigureServer pour définir l'hôte et le port

	// TODO: Afficher à nouveau la configuration pour montrer les valeurs mises à jour
}