Questo vale per C (e probabilmente per qualsiasi altro linguaggio simile non orientato agli oggetti). Se ho un archivio dati centrale e un accesso potenzialmente concorrente ci sono due modi in cui posso vedere di proteggerlo.
Diciamo che ho un archivio dati con alcuni elementi di dati ...
struct MyStore
{
int data1, data2, data3, ...., dataN;
} store[M];
In questo esempio i tipi di dati sono gli stessi ma immaginiamo che questo si applichi a qualcosa di un po 'più vario con tipi diversi ecc ... questo è solo per mantenere la domanda semplice.
Per consentire ad altri utenti l'accesso ai dati all'interno, potrei fare alcune cose.
- Potrebbe fornire funzioni di regione critiche e fare affidamento sul chiamante per ottenere la protezione corretta.
- Potrei fornire un setter e una funzione getter per ogni tipo di elemento dati nel negozio e gestire le aree critiche all'interno del modulo e proteggere l'utente dall'avere a che fare con qualsiasi logica.
Il mio problema con il primo metodo è che l'onere è posto sul chiamante.
Il mio problema con il secondo, almeno in C, è che in primo luogo finisco per scrivere un intero carico di accessori per le piastre della caldaia e in secondo luogo cose più complesse come test-and-set o che richiedono il blocco dei dati mentre si fa diverse operazioni diventano disordinate. Per esempio. per il metodo 2 ho bisogno di
int GetData1(unsigned int index) {
int data;
ENTER_CR();
data = store[index].data1;
LEAVE_CR();
return data;
}
...
...
int GetDataN(unsigned int index) {
int data;
ENTER_CR();
data = store[index].dataN;
LEAVE_CR();
return data;
}
E lo stesso per tutti i setter. E poi cosa succede se voglio impostare più oggetti atomicamente? Diventa difficile!
Come ottenere alcuni dei vantaggi di modularità e incapsulamento, ma hai ancora un'interfaccia flessibile?