robienie licznych wskaźników NULL w tym samym czasie

Question

To jest klasa C++, którą zrobiłem z n liczbą wskaźników.

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

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

Podczas fazy inicjalizacji, chcę, aby wszystkie te wskaźniki wskaż polecenie NULL (lub uczynić wskaźniki wskaż polecenie NULL domyślnie, gdy są one zadeklarowanej) zamiast tego:

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

Czy istnieje jakąkolwiek łatwą metodę osiągnięcia tego celu? Zastanawiam się, czy istnieją sposoby uniknięcia wpisywania n linii ptr = NULL; w mojej funkcji. Z góry dziękuję.

DODANO oparty na odpowiedziach, że otrzymałem dotąd: Niestety, te wskaźniki muszą być oddzielone, jak są one wykorzystywane do różnych celów. Zrobiłem nazwy wskaźników jako takie tylko po to, aby ustalić, co próbuję zrobić, ale każda z nich ma zupełnie inny cel. Sądzę, że musiałbym sprawić, by wskazywały na NULL, jak już zrobiłem. Dziękuję za odpowiedzi.

Answer 1

Dlaczego nie używasz tablicy lub wektora, zamiast tworzyć n pojedynczo wskazanych wskaźników? Następnie możesz wykonać zerowanie w krótkiej pętli for.

Answer 2

Można to zrobić:

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

Answer 3

pierwsze, technikę, która nie praca:

Wywołanie memset aby ustawić cały obiekt do zera nie zrobi. Po pierwsze, spowoduje to wiele problemów, jeśli twoja funkcja ma jedną lub więcej funkcji wirtualnych, a po drugie, wskaźnik zerowy nie może być reprezentowany przez wzorzec bitowy wszystkich zer.

To, co prawdopodobnie zrobiłbym w twoim przypadku, to przechowywanie wskaźników w tablicy lub wektorze. Następnie można użyć funkcji std::fill, aby ustawić wszystkie na NULL. (Lub możesz użyć pętli, jeśli wolisz)

Oczywiście, jeśli chcesz zrobić to wystarczająco często, może warto napisać klasę wrapper, która zachowuje się jak wskaźnik, ale która ustawia ją na NULL w swoim domyślnym konstruktor.

Lub możesz użyć boost :: optional, który działa w zasadzie tak jak to. (Choć nie jest to specyficzne dla wskaźników)

Answer 4

Dlaczego nie używać domyślnego konstruktora:

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

} 

Można również zrobić:

ptr1 = ptr2 = ptr3 = NULL; 

Answer 5

Użyj wektor do tego (bo przez dźwięki nie będziesz już musiał edytować tej listy w przyszłości - i potrzebujesz dostępu losowego). Można to zrobić tak:

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

Choć szczerze mówiąc to cuchnie ghettoness. Czy na pewno Twój problem wymaga tego rozwiązania? Jeśli rozwiążesz więcej na temat konkretnego problemu, na pewno w innym pytaniu, jestem pewien, że możesz uzyskać lepszą odpowiedź na pytanie, jak osiągnąć to, co chcesz, bardziej elegancko - zamiast tworzyć drugi problem.

Answer 6

Zamiast int *, utworzyć klasy smart-pointer-podobne, które działa dokładnie jak int *, ale default-konstrukty z 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 
}; 

Następnie wykorzystać go w swojej klasie:

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

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

Każda zmienna typu MyPointer<int> zostanie automatycznie zainicjowana poprawnie w konstruktorach SomeClass, bez konieczności dodatkowego pisania. Jeśli nie zapomnisz lub niepoprawnie zaimplementujesz jedną z metod MyPointer, będzie ona działać dokładnie tak, jak normalny wskaźnik i ma dokładnie taki sam rozmiar i wydajność.

Answer 7

Można umieścić wskaźniki w struct, a następnie memset() struct, gdy jest to konieczne. Wskaźniki są nadal rozdzielone, ale masz możliwość kierowania ich jako jednej jednostki bez wpływu na resztę klasy. Na przykład:

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

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

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

Answer 8

polecam Ci wykonać następujące czynności, jeśli masz do utrzymania wskaźników oddzielnie (chyba najbardziej naglące potrzeby byłoby gdyby wskaźniki mogą mieć różne rodzaje)

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

public: 
    void MakePtrNull(); 
}; 

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

ten działa, ponieważ inicjowanie wartości dla klas, które nie mają zadeklarowanego konstruktora, spowoduje zainicjowanie wartości wszystkich jego członków. Inicjalizacja wartości wskaźnika spowoduje utworzenie wskaźnika pustego.