Funkcja inicjalizująca przyjmująca jako argument początkową pojemność tablicy

Do zdefiniowania tablicy należy wykorzystać strukturę składającą się z trzech pól: adresu tablicy, aktualnej liczby elementów oraz aktualnej pojemności tablicy.
Funkcja inicjalizująca powinna przyjmować jako argument początkową pojemność tablicy i zwrócić wskaźnik do utworzonej struktury.
Mógłby mi ktoś pomóc z tą treścią ? Utworzenie tablicy dynamicznej to nie problem ale jak utworzyć ta funkcję inicjalizującą?

Chodzi o tablicę

pomyliłem się z tą tablicą.. muszę zaalokowac obiekt struktury, wypełnic go i zwrócic adres.

typedef int element_t;

struct container {
    element_t* address;
    unsigned int size;
    unsigned int capacity;
};

container* create(unsigned int capacity) {
    container* obj = new container;
    obj->address = new element_t[capacity];
    obj->size = 0;
    obj->capacity = capacity;
    return obj;
}

Zakładając, że przez "funkcję inicjalizującą" masz na myśli konstruktor oraz masz używać starego C++:

class Container
{
public:
    typedef int ValueType;

    ~Container() {
         delete values;
    }

    Container(int capacity)
        : mCapacity(capacity)
        , mSize(0)
        , mValues(new ValueType[capacity])
    {
    }

    Container(const Container& other)
        : mCapacity(other.size())
        , mSize(other.size())
        , mValues(new ValueType[mCapacity])
    {
        std::copy(other.mValues, other.mValues + mSize, mValues);
    }

    Container& operator=(const Container &other)
    {
        if (capacity() < other.size()) {
              reserve(other.size());
        }
        mSize = other.size();
        std::copy(other.mValues, other.mValues + size(), mValues);
    }

    ValueType at(size_t i) const {
        if (i >= mSize) throw std::invalid_argument("Index out of range");
        return mValues[i];
    }

    void append(ValueType x)
    {
        if (mSize == mCapacity) reserve(3 * mSize / 2);
        mValues[mSize ++] = x;
    }

    size_t size() const { return mSize; }
    size_t capacity() const { return mCapacity; }

private:
    void reserve(size_t) {
          throw std::logic_error("Capacity update not implemented");
    }
    size_t mCapacity;
    size_t mSize;
    ValueType* mValues;
};

Przy czym jest to upośledzona wersja std::vector