facendo numerosi puntatori NULL allo stesso tempo

Question

Questa è una classe C++ che ho creato con n numero di puntatori.

class SomeClass 
{ 
private: 
     int* ptr1; 
     int* ptr2; 
     ... 
     int* ptrn; 

private: 
     // constructors, destructors, and methods 
}; 

Durante la fase di inizializzazione, Voglio fare tutte quelle puntatori punto a NULL (o fare puntatori punto a NULL per impostazione predefinita quando sono dichiarate), piuttosto che farlo:

void SomeClass::MakePtrNull() 
{ 
     ptr1 = NULL; 
     ptr2 = NULL; 
     ... 
     ptrn = NULL; 
} 

C'è qualsiasi metodo facile per raggiungere questo obiettivo? Mi sto solo chiedendo se ci sono modi per evitare di digitare n righe di ptr = NULL; nella mia funzione. Grazie in anticipo.

AGGIUNTO sulla base delle risposte che ho ricevuto finora: Purtroppo, questi puntatori devono essere separati, in quanto sono utilizzati per scopi diversi. Ho fatto i nomi dei puntatori in quanto tali solo per capire cosa sto cercando di fare, ma ogni puntatore ha uno scopo completamente diverso. Credo che dovrei farli puntare a NULL come ho già fatto. Grazie per le tue risposte.

Answer 1

Perché non si utilizza un vettore o un vettore piuttosto che creare n puntatori nominati singolarmente? Quindi puoi annullare il tutto in un ciclo breve.

Answer 2

Si può fare questo:

void SomeClass::MakePtrNull() 
{ 
     ptr1 = ptr2 = ptr3 = ... = ptrn = NULL; 
} 

Answer 3

In primo luogo, la tecnica che non lavoro:

Calling memset per impostare l'intero oggetto a zero non lo farà. Innanzitutto, causerà un sacco di problemi se la tua funzione ha una o più funzioni virtuali e, in secondo luogo, non è garantito che un puntatore nullo sia rappresentato da un modello di bit di tutti gli zeri.

Quello che probabilmente farei nel tuo caso è memorizzare i puntatori in un array o in un vettore. Quindi è possibile utilizzare la funzione std::fill per impostarli tutti su NULL. (Oppure si può usare un loop se si preferisce)

Naturalmente, se è necessario farlo abbastanza spesso, può valere la pena scrivere una classe wrapper che si comporta come puntatore, ma che imposta su NULL nel suo valore predefinito costruttore.

Oppure è possibile utilizzare boost :: opzionale che funziona essenzialmente in questo modo. (Anche se non è specifica per i puntatori)

Answer 4

perché non utilizzare un costruttore di default:

SomeClass::SomeClass() : ptr1(NULL), ptr2(NULL), ... 
{ 

} 

Si potrebbe anche fare:

ptr1 = ptr2 = ptr3 = NULL; 

Answer 5

Utilizzare un vettore per questo (perché dai suoni della in futuro non avrai più bisogno di modificare la lista e avrai bisogno di un accesso casuale). Si può fare in questo modo:

class PointerList 
{ 
private: 
    typedef std::vector<int*> IntPtrVector; 
    IntPtrVector m_ptrVec; 

public: 
    PointerList() 
    { 
     m_ptrVec.reserve(5); 
     for (int i = 0; i < 5; i++) 
      m_ptrVec.push_back(NULL); 
    } 

    int* getPointer(int index) 
    { 
     return m_ptrVec[index]; 
    } 

    void setPointer(int index, int* ptr) 
    { 
     assert(index <= 4); 
     m_ptrVec[index] = ptr; 
    } 
}; 

EDIT

anche se ad essere onesti questo puzza di ghettoness. Sei sicuro che il tuo problema richieda questa soluzione? Se approfondisci il tuo problema specifico, forse in un'altra domanda, sono sicuro che puoi ottenere una risposta migliore su come ottenere ciò che desideri in modo più elegante, piuttosto creando un secondo problema.

Answer 6

Invece di int *, creare una classe di smart-pointer-like, che funziona esattamente come un int *, ma default-costrutti con NULL:

template <typename T> 
class MyPointer { 
    T *p; 

public: 
    MyPointer() : p(NULL) { } 
    MyPointer(T *o) : p(o) { } 
    operator T*() const { return p; } 
    // ...and the rest of the traditional smart-pointer operators 
}; 

Quindi, utilizzare il metodo nella classe:

class SomeClass 
{ 
private: 
     MyPointer<int> ptr1; 
     MyPointer<int> ptr2; 
     ... 
     MyPointer<int> ptrn; 

private: 
     // constructors, destructors, and methods 
}; 

Ogni variabile del tipo MyPointer<int> verrà automaticamente inizializzata correttamente nei costruttori di SomeClass, senza necessità di digitazione aggiuntiva. Se non hai dimenticato o implementato in modo errato uno qualsiasi dei metodi di MyPointer, funzionerà esattamente come un normale puntatore e avrà esattamente le stesse dimensioni e le stesse prestazioni.

Answer 7

È possibile inserire i puntatori in una struttura e quindi memset() la struct quando necessario. I puntatori sono ancora separati, ma hai i mezzi per bersagliarli come una singola unità senza influenzare il resto della tua classe. Per esempio:

struct MyPointers 
{ 
    int* ptr1; 
    int* ptr2; 
    ... 
    int* ptrn; 
}; 

class SomeClass 
{ 
private: 
    MyPointers ptrs; 
    ... 
}; 

void SomeClass::MakePtrNull() 
{ 
    memset(&ptrs, 0, sizeof(ptrs)); 
} 

Answer 8

vi consiglio di fare quanto segue, se si deve mantenere i puntatori separatamente (probabilmente l'esigenza più pressante sarebbe se i puntatori possono avere diversi tipi)

class SomeClass { 
    struct Pointers { 
     int* ptr1; 
     int* ptr2; 
     float* ptrn; 
    } ptrs; 

public: 
    void MakePtrNull(); 
}; 

void SomeClass::MakePtrNull() 
{ 
    // clears all pointers at once 
    ptrs = Pointers(); 
} 

Questo funziona, perché l'inizializzazione del valore per le classi che non hanno un costruttore dichiarato dall'utente valuterà l'inizializzazione di tutti i suoi membri. L'inizializzazione del valore di un puntatore creerà un puntatore nullo.