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 renvoie un pointeur vers celui-ci. La mémoire allouée est initialisée avec 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)

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

Avec les structures, new() crée un pointeur vers une structure dont tous les champs sont définis sur leurs valeurs nulles.

type Person struct {
    Name string
    Age  int
}

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

Tu te demandes peut-être quand utiliser new() plutôt que 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 souhaitez spécifiquement une instance ayant des valeurs nulles et préférez une sémantique d’allocation de mémoire explicite.

Défi

Facile

Construisons un gestionnaire de configuration qui montre comment new() alloue de la mémoire et initialise les structures avec leurs valeurs zéro. Tu verras en quoi cette approche diffère de l’utilisation de l’opérateur d’adresse avec un littéral de structure.

Tu organiseras ton code sur deux fichiers :

config.go : définis une structure ServerConfig avec les champs Host (string), Port (int), MaxConnections (int) et DebugMode (bool). Crée deux fonctions :
- NewServerConfig qui utilise new() pour allouer un ServerConfig et renvoie directement le pointeur (avec toutes les valeurs zéro)
- ConfigureServer qui prend un pointeur *ServerConfig ainsi qu’une chaîne représentant l’hôte et un entier représentant le port, puis définit ces champs dans la configuration via le pointeur
Ajoute également une méthode Display sur *ServerConfig qui renvoie une chaîne formatée affichant toutes les valeurs de configuration.
main.go : lis un hôte et un port depuis l’entrée. Commence par créer une configuration avec NewServerConfig() et affiche-la pour montrer les valeurs zéro. Utilise ensuite ConfigureServer pour définir l’hôte et le port, puis affiche à nouveau la configuration pour montrer les valeurs mises à jour.

Les entrées suivantes seront fournies :

Ligne 1 : Nom d’hôte (chaîne)
Ligne 2 : Numéro de port (entier)

Ta méthode Display doit renvoyer une chaîne dans ce format exact :

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

Affiche le résultat deux fois, une fois avant la configuration (en montrant les valeurs zéro), puis une fois après la configuration (en montrant l’hôte et le port mis à jour).

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

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

Remarque que le premier affichage montre toutes les valeurs zéro (chaîne vide, 0, 0, false), car new() initialise tout avec les valeurs zéro. Après l’appel à ConfigureServer, seuls l’hôte et le port changent, tandis que les autres champs conservent leurs valeurs zéro.

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 config en utilisant NewServerConfig() et l'afficher
	// Cela montrera les valeurs zéro

	// TODO: Utiliser ConfigureServer pour définir le host et le port

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