создание многочисленного ПУСТОГО УКАЗАТЕЛЯ указателей одновременно

Вместо int * , создайте класс, подобный интеллектуальному указателю, который работает точно так же, как int * , но конструкции по умолчанию с 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
};

Затем используйте его в своем классе:

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

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

Каждая переменная из Тип MyPointer будет автоматически правильно инициализирован в конструкторах SomeClass без необходимости дополнительного набора текста. Если вы не забыли или неправильно реализовали какой-либо из методов MyPointer , он будет действовать точно так же, как обычный указатель, и иметь точно такой же размер и производительность.

без необходимости дополнительного набора текста. Если вы не забыли или неправильно реализовали какой-либо из методов MyPointer , он будет действовать точно так же, как обычный указатель, и иметь точно такой же размер и производительность.

без необходимости дополнительного набора текста. Если вы не забыли или неправильно реализовали какой-либо из методов MyPointer , он будет действовать точно так же, как обычный указатель, и иметь точно такой же размер и производительность.

Вы можете сделать это:

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

Я рекомендую вам сделать следующее, если вам нужно хранить указатели отдельно (вероятно, наиболее насущная необходимость будет, если указатели могут иметь разные типы)

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

public:
    void MakePtrNull();
};

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

Это действительно работает, потому что value-initialization для классов, у которых нет объявленного пользователем конструктора, будет инициализировать value все его члены. При инициализации значения указателя будет создан нулевой указатель.

Во-первых, метод, который не работает :

Вызов memset для установки весь объект до нуля не годится. Во-первых, это вызовет много проблем, если ваша функция имеет одну или несколько виртуальных функций, а во-вторых, нулевой указатель не обязательно будет представлен битовым шаблоном из всех нулей.

В вашем случае, вероятно, я бы сохранил указатели в массиве или векторе. Затем вы можете использовать функцию std :: fill , чтобы установить их все в NULL. (Или вы можете использовать цикл, если хотите)

Конечно, если вам нужно делать это достаточно часто, возможно, стоит написать класс-оболочку, который ведет себя как указатель, но устанавливает его в NULL в конструкторе по умолчанию .

Или вы можете использовать boost :: optional, которая работает примерно так. (хотя это не относится к указателям)

Почему бы не использовать конструктор по умолчанию:

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

}

Вы также можете сделать:

ptr1 = ptr2 = ptr3 = NULL;

Используйте для этого вектор (потому что, судя по всему, вам не нужно будет редактировать список в будущем - и вам понадобится произвольный доступ). Сделать это можно так:

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;
    }
};

РЕДАКТИРОВАТЬ

Хотя, честно говоря, от этого пахнет геттоном. Вы уверены, что ваша проблема требует этого решения? Если вы подробно остановитесь на своей конкретной проблеме, возможно, в другом вопросе, я уверен, что вы сможете лучше ответить о том, как добиться того, что вы хотите, более элегантно - вместо того, чтобы создавать вторую проблему.

Вы можете поместить указатели в структуру, а затем memset () структуру, когда это необходимо. Указатели по-прежнему разделены, но у вас есть средства нацеливания на них как на единое целое, не затрагивая остальную часть вашего класса. Например:

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

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

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