Esiste una differenza funzionale tra tipi di valore immutabili e tipi di riferimento immutabili?

Stai definendo tipi di valore e riferimento in modo agnostico rispetto alla lingua, ma lo fai solo con l'esempio in termini di modifica dei membri dei dati. Logicamente, rendere immutabili i tipi ti fa perdere l'unica differenza garantita dalla tua definizione (e la risposta potrebbe essere "no").

Tuttavia, quando iniziamo a guardare determinati linguaggi di programmazione, allora sì: ci sono più differenze.

Considera il seguente esempio in C #.

void increment()
{
    lock (synchro)
    {
        total++;
    }
}

private int total = 0;
private SomeType synchro;

Se SomeType è un tipo di riferimento, questo contatore sarà thread-safe. Se SomeType è un tipo di valore, quindi, a causa del pugilato, ogni thread blocca una copia di synchro e gli incrementi potrebbero essere persi in concorrenza.

Naturalmente, non ci sono tipi immutabili genuini in .NET nel senso più astratto, in quanto i monitor coinvolti sono implementati usando campi nascosti (come la parola chiavemutable del C ++ che può dichiarare membri mutabili in tipi altrimenti immutabili). Ma su Stack Overflow, tutti capiranno che la tua domanda fa riferimento a qualsiasi cosa che la loro piattaforma definisce "immutabile".

Sì, l'uguaglianza differisce ancora:

a: value type = 4;
b: value type = 4;

c: reference type = 4;
d: reference type = 4;

a == b; // true;
c == d; // false;

I trucchi C # per cose come le stringhe consolanciando riferimenti equivalenti, ma questo non è strettamente necessario per i tipi di riferimento immutabili.

Il valore rispetto al tipo di riferimento è non un termine agnostico. Un linguaggio come C ++ e C non ha una distinzione, è un'imposizione arbitraria di alcune lingue. Comunque, ci provo comunque a rotolare con esso.

Un semplice esempio è sizeof(T) . Tutti i tipi di riferimento hanno le dimensioni di un puntatore (probabilmente più le dimensioni di un altro puntatore, a seconda di quale sia il tuo sistema di gestione della memoria). I tipi di valore, tuttavia, non lo fanno. Inoltre, è possibile misurare le caratteristiche delle prestazioni per determinare se si ha a che fare con un valore o un tipo di riferimento. Inoltre, non è particolarmente sicuro fare riferimento a tipi di valori in alcuni contesti.

I tipi di riferimento possono fare cose che i tipi di valore immutabili non riescono, ad esempio, i riferimenti ad essi possono rimbalzare su un'altra istanza.

class X {
    const int imm;
    X() : imm(0) {}
};
class Y {
    const int* imm;
    Y() : imm(new int(0));
};
X x;
Y y;
y.imm = new int(5); // Whoops! The reference itself is not immutable.

Fondamentalmente, deve sempre essere noto se un tipo è un valore o un riferimento, altrimenti non è possibile generare il codice corretto per accedervi.

In breve: un tipo di valore contiene i dati all'interno della propria allocazione di memoria e un tipo di riferimento contiene un puntatore a un'altra posizione di memoria che contiene i dati reali. Le variabili del tipo di riferimento sono memorizzate nell'heap mentre le variabili del tipo di valore sono memorizzate nello stack.

Altro: differenza tra un tipo di valore e un tipo di riferimento