Costruire stringhe

Il testo nuovo deve stare da qualche parte

Tutto quello che hai fatto con le stringhe finora lavorava su testo già esistente: tagliare, confrontare, cercare. Ma come si crea una stringa che prima non c’era, per esempio "Ada (level 7)" a partire dal nome e da un numero?

Il problema non è il formato: printfn lo sa fare da sempre. Il problema è dove mettere il risultato. Una String è una finestra, e una finestra deve guardare dei byte che esistono da qualche parte. I letterali stanno nel programma, gli array locali nello stack (e spariscono con la funzione, come hai visto nella lezione sulle slice). Per il testo costruito mentre il programma gira serve un posto nuovo.

C3 ti offre due strade. La prima è quella classica del C: chiedi memoria allo heap e la restituisci tu. La seconda, molto più comoda per il lavoro di tutti i giorni, è la memoria temporanea. Cominciamo da questa.

La memoria temporanea e la t

La libreria standard ha una zona di memoria pensata per i risultati “usa e getta”: li crei, li usi per un po’, e poi vengono buttati via tutti insieme, senza che tu debba pensarci uno per uno. Le funzioni che la usano si riconoscono dalla t davanti al nome (temp). La più usata è string::tformat, sorella di printfn, che invece di stampare restituisce la stringa:

String name = "Ada";
int level = 7;
String label = string::tformat("%s (level %d)", name, level);
io::printn(label);
io::printn(label.len);

Ada (level 7)
13

Stessi segnaposto di printf, stesso modo di usarla. E siccome la memoria temporanea non sparisce alla fine della funzione, una funzione può restituire una stringa costruita così:

fn String greeting(String name, int age)
{
	return string::tformat("%s is %d years old", name, age);
}

io::printn(greeting("Grace", 85));

Grace is 85 years old

(Non serve nessun import in più: string:: fa parte del cuore della libreria standard, come io::.)

Altre funzioni con la t, tutte sulle stringhe, e tutte che restituiscono testo nuovo senza toccare l’originale:

io::printn("snake".tconcat("_case"));            // glue two strings
io::printn("quiet please".to_upper_tcopy());     // uppercase copy
io::printn("2026-09-25".treplace("-", "/"));     // replace every "-"

snake_case
QUIET PLEASE
2026/09/25

Spezzare e riunire

Due operazioni che userai di continuo: spezzare un testo in pezzi, e rimettere insieme dei pezzi.

String[] parts = "red,green,blue".tsplit(",");
io::printfn("%d parts: %s", parts.len, parts);
io::printn(string::tjoin(parts, " + "));

3 parts: [red, green, blue]
red + green + blue

tsplit restituisce una slice di String, String[]: una fila di finestre, ognuna su un pezzo del testo originale. La fila stessa sta nella memoria temporanea (è stata creata ora, e la sua lunghezza non era nota prima). tjoin fa il contrario: prende i pezzi e li incolla in una stringa nuova, con un separatore in mezzo.

DString: il costruttore di stringhe

Quando il testo si costruisce un pezzo alla volta, magari in un ciclo, tformat diventa scomodo. Per questo c’è DString (dynamic string): una stringa che cresce man mano che ci aggiungi roba.

DString text;
text.append("Hello");
text.append(", ");
text.appendf("%s!", name);    // like printf, but into the string
text.append('!');             // a single char works too
io::printn(text);
io::printn(text.len());

Hello, Ada!!
12

append aggiunge in fondo un testo o un carattere; appendf aggiunge testo formattato, ed è quella da usare per i numeri. (Occhio: text.append(42) non scrive 42 ma il carattere con codice 42, cioè *. Un char è un numero, ricordi?) Nota le parentesi in text.len(): DString non è una slice, e la lunghezza gliela chiedi con un metodo.

Il posto naturale di un DString è dentro un ciclo:

text.clear();                  // empty it, ready to reuse
for (int i = 1; i <= 5; i++)
{
	if (i > 1) text.append(" - ");
	text.appendf("%d", i * i);
}
io::printn(text);

1 - 4 - 9 - 16 - 25

Quando hai finito di costruire e vuoi usare il risultato come una normale String (per esempio per passarlo a una funzione che vuole una String), chiedi una finestra sul testo con str_view():

String result = text.str_view();
io::printn(result.ends_with("25"));

true

E la memoria? Un DString dichiarato così, senza altre indicazioni, usa automaticamente la memoria temporanea. Niente da liberare.

@pool: fare pulizia

La memoria temporanea non è infinita: cosa succede se crei stringhe in un ciclo che gira un milione di volte? Ognuna occupa un po’ di spazio, e nessuna viene buttata. Qui entra in gioco @pool: un blocco che, quando finisce, libera tutta la memoria temporanea usata al suo interno.

for (int round = 0; round < 3; round++)
{
	@pool()
	{
		String line = string::tformat("round %d", round);
		io::printn(line);
	};   // everything temporary created in here is gone
}

round 0
round 1
round 2

Nota il punto e virgola dopo la graffa di chiusura: @pool è una macro (la @ lo indica), e le macro con un blocco si chiudono così. Delle macro parleremo a lungo più avanti; per ora trattala come una forma speciale da scrivere così com’è.

A ogni giro del ciclo, @pool libera la stringa di quel giro. Il consumo di memoria resta piatto, per quanti giri tu faccia. E fuori da qualsiasi @pool? La memoria temporanea viene liberata quando il programma finisce: per i programmi piccoli di questo corso va benissimo così, ed è per questo che negli esempi precedenti non c’era.

const String SENTENCE = "the quick brown fox jumps over the lazy dog";

import std::io;

const String SENTENCE = "the quick brown fox jumps over the lazy dog";

fn void main()
{
	String[] words = SENTENCE.tsplit(" ");

	DString title;
	DString initials;
	String longest = words[0];
	foreach (i, word : words)
	{
		if (i > 0) title.append(" ");
		title.append(word[0].to_upper());
		title.append(word[1..]);
		initials.append(word[0].to_upper());
		if (word.len > longest.len) longest = word;
	}

	io::printfn("Title: %s", title);
	io::printfn("Initials: %s", initials);
	io::printfn("Words: %d, longest: %s (%d)", words.len, longest, longest.len);
	io::printfn("Snake: %s", SENTENCE.treplace(" ", "_"));
}

Ricapitolando

• Il testo nuovo ha bisogno di memoria nuova. La più comoda è la memoria temporanea, usata dalle funzioni con la t.
• string::tformat è printf che restituisce una String; tconcat, treplace, to_upper_tcopy creano stringhe nuove.
• s.tsplit(",") spezza in un String[]; string::tjoin(parts, ", ") riunisce.
• DString cresce con append e appendf; len() ne dà la lunghezza, str_view() una String, clear() lo svuota.
• @pool() { ... }; libera tutta la memoria temporanea usata nel blocco: mai usare dopo quello che ci è nato dentro.
• Per risultati a lunga vita: string::format(mem, ...) e poi free.

Resta un ultimo tassello: una collezione di numeri (o di qualsiasi altra cosa) che cresce come un DString. Le liste.