puntatore condiviso o raw c ++

Question

puntatore condiviso o raw c ++

#1 da (1 voti)
#2 da (1 voti)

1

Sto sviluppando un database noSQL e attualmente sto spostando il codice da C a C ++.

Ha classe Pair , che contiene un puntatore raw a un blob di memoria.

class Pair {
  Blob* blob;
  ...
};

Quindi se aggiungi questo Pair alla classe List , la classe List memorizza internamente questo puntatore raw, senza copiare. Per non perdere memoria, List notifica il Pair non a delete del puntatore raw.

class Pair {
  Blob* _blob;
  bool _owns_blob;

public:
  Pair(Blob* blob, bool owns_blob = true)
    : _blob(blob), _owns_blob(owns_blob) {}
  ~Pair() { if (_owns_blob) delete _blob; }
  ...
  Blob* blob() { return _blob; }
  void disown() { _owns_blob = false; }
};

void List::put(Pair& p) {
  store_blob(p.blob());
  p.disown();
}

A causa di questa notifica, non posso usare una firma del metodo come questa:

List.put(const Pair &p)

e dovrò passare per valore o per riferimento non const.

In seguito, se richiedi i dati, il programma crea un new Pair e include il puntatore raw all'interno e indica anche Pair a delete del puntatore:

Pair List::get(...) {
  return Pair(get_blob(), false);
}

Questo modello trarrebbe vantaggio da indicatori condivisi? In che modo ciò influisce sulla velocità e sul consumo di memoria?

c++ pointers

posta Nick 28.06.2015 - 11:14

fonte

2 risposte

Leggi altre domande sui tag c++ pointers

Restituisce un riferimento all'interno di una cattiva pratica del vettore privato? Approccio corretto per la creazione di un contratto API

score 1 · Answer 1

Non sono C ++ - Esperto, ma negli ultimi giorni ho fatto qualche ricerca sui puntatori "intelligenti", quindi forse posso aiutarti:

I puntatori condivisi potrebbero aiutarti in questa situazione, ma potrebbero essere semplicemente un modo troppo semplice per uscire da una situazione in cui non è chiaro in primo luogo a chi appartengono realmente i dati. L'accesso a un puntatore condiviso è economico, ma la copia ha una piccola penalità in quanto deve essere eseguito un conteggio dei riferimenti in background.

Se stai programmando in c ++ 11, prova a ridisegnare le tue classi (se possibile) usando unique_ptr con la semantica di movimento che non ha un sovraccarico.

score 1 · Answer 2

Would this model benefit from shared pointers?

Sembra che tu abbia in mano i puntatori e ne diventi proprietario. Sembra anche che il codice client non condivida la proprietà. A questo punto (heh punny!), Trarrai vantaggio dall'implementazione di questo in termini di std::unique_ptr e esponendo un wrapper sicuro personalizzato attorno a un puntatore o un Blob* const al codice client.

How would this [using std::shared_ptr] affect the speed and memory consumption?

Per quanto riguarda la velocità, non possiamo dire, a meno che non conosciamo tutti i tuoi algoritmi, e anche allora, potremmo non essere in grado di dire fino a quando non misuri.

Con i puntatori condivisi, la velocità verrà influenzata, ma nessuno può dire se questo è significativo finché non si misura (la modifica diminuirà le prestazioni, ma se le modifiche non sono sul percorso di esecuzione critico, tali riduzioni sarebbero rese insignificanti da altri colli di bottiglia delle prestazioni).

Per quanto riguarda il consumo di memoria, un puntatore condiviso ha una impronta di piede ~ tre volte più grande di un puntatore raw: - il puntatore dati stesso - il conteggio dei riferimenti - il puntatore all'oggetto interno che contiene i due valori sopra.

Questo sarà significativo se memorizzi molti molti (molti molti molti) puntatori e insignificante altrimenti.