Array of pointers data structure

I don't think that this data structure has any special name(vector of pointers sounds reasonable).

Now about the code itself:

1. I do not see any reason to use void* pointers here and cast them explicitly every time you access an element. You can just use vector<T*> addresses and get rid of all casts. You can also use smart pointers(unique_ptr looks like a good choice here). Here is my version of this class:

   template<class T>
   class PointerArray {
   public:
       PointerArray(size_t initialSize = 100): array(initialSize) {}
   
       T& operator[](size_t pos) {
           if (pos >= array.size()) {
               size_t newSize = std::max(pos + 1, 2 * pos);
               array.resize(newSize);
           }
           if (!array[pos]) {
               array[pos] = std::unique_ptr<T>(new T()); // or std::make_unique in C++14
           } 
           return *array[pos];
       }
   
   private:
       std::vector<std::unique_ptr<T>> array;
   };
   

   There no need for a custom destructor anymore(unique_ptr handles it). Note that I have added this line: int newSize = std::max(pos + 1, 2 * pos);. Why is it necessary? We need it when the initialSize is 0 and so is pos.

2. In this line: if(pos >= addresses.capacity()), you should be comparing pos to the vector's size, not capacity(because it is an undefined behavior to access elements of the vector beyond size).

3. More general notes:

   • using namespace std; is a bad practice. There is no need to pollute global namespace.

   • Binary operators are usually surrounded with whitespaces. It is also conventional to have an empty line between different functions to improve readability.

4. And the last one: do have good reasons to use this data structure? In my opinion, as long as a simple std::vector<T> works fine, there is no need to invent any new data structures.

In addition to what kraskevich said (especially about smart pointers), I would also implement a proper copy constructor and assignment operator (or explicitly delete them).

Your current version would produce a shallow copy (and as a result UB when deleting referenced objects a second time). Kraskevich's solution doesn't have a copy constructor at all, as std::unique_ptr cannot be copied. While this is better than having a faulty copy constructor, you should try to stay more in line with the behavior of the standard library containers.

Also missing is a size() function:

#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <algorithm>

template <class T>
class pointerArray
{
    std::vector<std::unique_ptr<T>> addresses; //<-- Use unique_ptr -> no delete function needed
public:
    pointerArray(size_t initialSize = 100) : //<-- use size_t
        addresses(initialSize)
    {}

    pointerArray(const pointerArray& other)  { //<-- implement deep copy
        addresses.resize(other.addresses.size());
        for (size_t i = 0; i < addresses.size(); ++i) {
            if (other.addresses[i] != nullptr) {
                addresses[i] = std::unique_ptr<T>(new T(*other.addresses[i]));
            }
        }
    }

    pointerArray(pointerArray&& other) = default; //<-- default move constructor does exactly what it is supposed to do

    pointerArray& operator=(pointerArray other) { //<-- could be made minimally more efficent by implementing separate copy and move assigment operators
        addresses=std::move(other.addresses );
        return *this;
    }

    size_t size() { return addresses.size(); } //<-- handy when passed as a parameter

    T& operator[](size_t pos)   {
        if (pos >= addresses.size()) { //<-- compare against size, not capacity
            addresses.resize(pos+1);
        }
        if (addresses[pos] == nullptr) { //<-- compare against nullptr
            addresses[pos] = std::unique_ptr<T>(new T());
        }
        return *addresses[pos];
    }
};