Cosa significa per una struttura dati essere "invadente"?

Ho visto il termine invadente usato per descrivere strutture di dati come elenchi e pile, ma cosa significa?

Puoi fornire un esempio di codice di una struttura di dati intrusiva e in che modo differisce da una non intrusiva?

Inoltre, perché renderlo invadente (o non invadente)? Quali sono i vantaggi? Quali sono gli svantaggi?

Una struttura dati intrusiva è quella che richiede l'aiuto degli elementi che intende archiviare per memorizzarli.

Lasciatemi riformulare. Quando metti qualcosa in quella struttura dati, quel "qualcosa" diventa consapevole del fatto che è in quella struttura dati, in qualche modo. L'aggiunta dell'elemento alla struttura dati modifica l'elemento.

Ad esempio, puoi creare un albero binario non intrusivo, in cui ogni nodo ha un riferimento ai sottoalberi sinistro e destro e un riferimento al valore dell'elemento di quel nodo.

Oppure puoi crearne uno intrusivo in cui i riferimenti a quei sottoalberi sono incorporati nel valore stesso.

Un esempio di una struttura di dati intrusiva sarebbe un elenco ordinato di elementi che sono mutabili. Se l'elemento cambia, l'elenco deve essere riordinato, quindi l'oggetto elenco deve intromettersi nella privacy degli elementi per ottenere la loro collaborazione. vale a dire. l'elemento deve conoscere l'elenco in cui si trova e informarlo dei cambiamenti.

I sistemi ORM di solito ruotano attorno a strutture di dati intrusive, per ridurre al minimo l'iterazione su grandi elenchi di oggetti. Ad esempio, se si recupera un elenco di tutti i dipendenti nel database, quindi si cambia il nome di uno di essi e si desidera salvarlo di nuovo nel database, l'elenco intrusivo dei dipendenti verrà comunicato quando l'oggetto dipendente è cambiato perché quello l'oggetto sa in quale elenco si trova.

Un elenco non invadente non sarebbe stato raccontato e avrebbe dovuto capire cosa è cambiato e come è cambiato da solo.

In un contenitore intrusivo i dati stessi sono responsabili della memorizzazione delle informazioni necessarie per il contenitore. Ciò significa che da un lato il tipo di dati deve essere specializzato a seconda di come verrà memorizzato, dall'altro significa che i dati "sanno" come vengono memorizzati e quindi possono essere ottimizzati leggermente meglio.

Non intrusivo:

template<typename T>
class LinkedList
{
  struct ListItem
  {
    T Value;
    ListItem* Prev;
    ListItem* Next;
  };

  ListItem* FirstItem;
  ListItem* LastItem;

  [...]
  ListItem* append(T&& val)
  {
    LastItem = LastItem.Next = new ListItem{val, LastItem, nullptr};
  };
};

LinkedList<int> IntList;

Invadente:

template<typename T>
class LinkedList
{
  T* FirstItem;
  T* LastItem;

  [...]
  T* append(T&& val)
  {
    T* newValue = new T(val);
    newValue.Next = nullptr;
    newValue.Prev = LastItem;
    LastItem.Next = newValue;
    LastItem = newValue;
  };
};

struct IntListItem
{
  int Value;
  IntListItem* Prev;
  IntListItem* Next;
};

LinkedList<IntListItem> IntList;

Personalmente preferisco il design invadente per la sua trasparenza.