Riepilogo e sfida finale

Dai valori alle collezioni

All’inizio del modulo sapevi tenere un valore per variabile, e un array visto di sfuggita. Adesso sai:

• usare gli array fissi fino in fondo, anche a due dimensioni, sapendo che sono valori che si copiano;
• guardarli a pezzi con le slice, senza copiare nulla, e scrivere funzioni che accettano collezioni di qualsiasi lunghezza;
• trattare il testo come quello che è, una slice di byte: tagliarlo, confrontarlo, cercarci dentro, esaminarlo carattere per carattere;
• costruire testo nuovo con tformat e DString, e raccogliere valori in una lista che cresce;
• distinguere dove vivono i dati: letterali in sola lettura, variabili locali nello stack, memoria temporanea da pulire con @pool.

L’ultimo punto è quello che ti porterai dietro più a lungo. “Chi possiede questi byte, e fino a quando esistono?” è la domanda che separa chi programma in C3 (o in C) da chi usa linguaggi che se ne occupano da soli.

La pagina da tenere accanto

Cinque errori che ormai riconosci

E due errori che il compilatore non vede, e che ora sai riconoscere dai sintomi: numeri a caso da una slice che guarda un array locale ormai sparito, e ����� da una stringa temporanea usata dopo il suo @pool.

Quiz di controllo

La sfida: la classifica

Un programma che legge dati grezzi, li interpreta e presenta un risultato: è la forma di una quantità enorme di software vero. Qui i dati arrivano come un’unica stringa, un registro di partite con il nome del giocatore e i punti fatti.

const String LOG = "ada:42,grace:17,linus:8,ada:30,barbara:55,grace:25,linus:12";

Entries: 7, players: 4
Ada       72 #######
Grace     42 ####
Linus     20 ##
Barbara   55 #####
Winner: Ada with 72 points

import std::io;
import std::collections::list;

const String LOG = "ada:42,grace:17,linus:8,ada:30,barbara:55,grace:25,linus:12";

fn int parse_number(String digits)
{
	int value = 0;
	foreach (c : digits)
	{
		value = value * 10 + (c - '0');
	}
	return value;
}

fn String capitalize(String word)
{
	return string::tformat("%c%s", word[0].to_upper(), word[1..]);
}

fn void main()
{
	List{String} names;
	List{int} totals;

	String[] entries = LOG.tsplit(",");
	foreach (entry : entries)
	{
		String[] parts = entry.tsplit(":");
		String name = parts[0];
		int points = parse_number(parts[1]);

		bool found = false;
		for (sz i = 0; i < names.len(); i++)
		{
			if (names[i] == name)
			{
				totals[i] += points;
				found = true;
				break;
			}
		}
		if (!found)
		{
			names.push(name);
			totals.push(points);
		}
	}

	io::printfn("Entries: %d, players: %d", entries.len, names.len());

	sz best = 0;
	for (sz i = 0; i < names.len(); i++)
	{
		DString bar;
		for (int j = 0; j < totals[i] / 10; j++) bar.append('#');
		io::printfn("%-8s %3d %s", capitalize(names[i]), totals[i], bar);
		if (totals[i] > totals[best]) best = i;
	}

	io::printfn("Winner: %s with %d points", capitalize(names[best]), totals[best]);
}

Cosa succede nel Modulo 4

Le liste parallele della sfida ti hanno fatto sentire il limite: un giocatore è un nome e un punteggio, e tenerli in due collezioni separate è scomodo e rischioso. Nel prossimo modulo impari a creare tipi tuoi: le struct, che raccolgono valori diversi sotto un nome solo, e gli enum, per i valori che possono essere solo uno tra pochi (un seme delle carte, un giorno della settimana, lo stato di una partita). Con loro, i tuoi programmi cominceranno a descrivere il mondo con le sue parole.

Segna questa lezione come completata. Hai appena scritto un piccolo interprete di dati: non è poco.