making numerous pointers NULL at the same time

Question

This is a C++ class that I have made with n number of pointers.

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

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

During the initialization stage, I want to make all those pointers point to NULL (or make pointers point to NULL by default when they are declared) rather than doing so:

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

Is there any easy method of accomplishing this goal? I'm just wondering if there are any ways of avoiding typing n lines of ptr = NULL; in my function. Thanks in advance.

ADDED based on the answers that I have received so far: Unfortunately, those pointers have to be separate, as they are used for different purposes. I made the names of the pointers as such just to make a point of what I'm trying to do, but each pointer has a completely different purpose. I guess I would have to make them point to NULL as I have done already. Thanks for your answers.

Answer 1

Why don't you use an array or a vector rather than creating n individually named pointers? Then you can do the nulling in a short for loop.

Answer 2

You can do this:

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

Answer 3

First, the technique that does not work:

Calling memset to set the entire object to zero won't do. First, it'll cause a lot of trouble if your function has one or more virtual functions, and second, a null pointer is not guaranteed to be represented by a bit pattern of all zeros.

What I would probably do in your case is store the pointers in an array or a vector. Then you can use the std::fill function to set them all to NULL. (Or you could use a loop if you prefer)

Of course, if you need to do this often enough, it may be worth writing a wrapper class which behaves as the pointer, but which sets it to NULL in its default constructor.

Or you could use boost::optional which works essentially like this. (although it is not specific for pointers)

Answer 4

Why not use a default constructor:

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

}

You could also do:

ptr1 = ptr2 = ptr3 = NULL;

Answer 5

Use a vector for this (because by the sounds of it you won't need to ever edit the list in the future - and you need random access). You can do it like this:

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

Though to be honest this reeks of ghettoness. Are you sure your problem requires this solution? If you elaborate more on your specific problem, in another question perhaps, I'm sure you can get some better answer on how to accomplish what you want more elegantly - rather then by creating a second problem.

Answer 6

Instead of int *, create a smart-pointer-like class which works exactly like a int *, but default-constructs with 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
};

Then, use it in your class:

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

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

Every variable of the MyPointer<int> type will be automatically initialized correctly in SomeClass's constructors, without the need for any extra typing. If you did not forget or incorrectly implement any of MyPointer's methods, it will act exactly like a normal pointer, and have the exact same size and performance.

Answer 7

You could put the pointers into a struct and then memset() the struct when needed. The pointers are still separated, but you have the means of targeting them as a single unit without affecting the rest of your class. For example:

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

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

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

Answer 8

I recommend you to do the following, if you have to keep the pointers separately (probably the most pressing need would be if the pointers can have different types)

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

public:
    void MakePtrNull();
};

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

This does work, because value-initialization for classes that doesn't have a user declared constructor will value initialize all its members. Value initialization of a pointer will create a null pointer.