C++ class wrapper and placement new - c++

Question

I have a template container class that needs to associate additional information with each instance of the user specified type.
The container specifies a wrapper structure that contains the specified type and the additional information...
template<typename T> class Container
{
...
struct Wrapper
{
T mType;
int mInfo;
};
}
On initialization, the container is populated with dynamically allocated instances of Wrapper (i.e., Wrapper*). The user can pop() an instance, and the container will return a cast to T*. The user can push() an instance, which the container will cast back to Wrapper*.
This works fine if the datatype can be default constructed. However, this is not always the case and I want to let the user provide an allocation function, invoked during initialization, that constructs the datatype however it likes. It's ok for the container to require a specific signature for the function.
template<typename T> template<typename F> void Container<T>::init(F allocator);
What I'm struggling with is how to allocate a Wrapper while the function allocates the datatype. I've thought about using placement new, where the container allocates enough space for Wrapper and passes the address to the function to do a placement new of the datatype.
Is there a cleaner way to go about this?

Answer 1

You do not need allocation function for this. Instead, you need something like emplace_push from standard containers.

Answer 2

I would just add the parameters used for construction of T as template parameters for Container, and use them to construct a T. To allow dynamic construction of the T objects, the container constructor accepts as parameter a pointer to a function taking as parameter an integer for the creation rank, and the default parameters for T constructor, and returning a tuple of parameter for T constructor (std::tuple<U...> (*getInitParam)(int rank, U... params)):
template<typename T, typename ...U>
class Container {
struct Wrapper {
T mType;
int mInfo;
Wrapper(int mInfo, U... params): mType(params...), mInfo(mInfo) {}
};
std::stack<Wrapper *> stack;
int get_mInfo() {
static int info = 0;
return info++;
}
std::tuple<U...> (*getInitParam)(int rank, U... params);
public:
T* pop() {
// should control stack is not empty
Wrapper *w = stack.top();
stack.pop();
return &w->mType;
}
void push(T* type) {
char *p = reinterpret_cast<char *>(type);
p -= offsetof(Wrapper, mType);
Wrapper *w = reinterpret_cast<Wrapper *>(p);
// would need to control that *w is a valid Wrapper
stack.push(w);
}
void init(int n, U... params) {
std::tuple<U...> orig = std::make_tuple(params...);
for (int i=0; i<n; i++) {
if (getInitParam != nullptr) {
std::tie(params...) = orig;
std::tuple<U...> tparams = (*getInitParam)(i, params...);
std::tie(params...) = tparams;
}
Wrapper *w = new Wrapper(get_mInfo(), params...);
stack.push(w);
}
}
Container(std::tuple<U...> (*getInitParam)(int rank, U... params) = nullptr)
: getInitParam(getInitParam) {}
~Container() {
while(! stack.empty()) {
Wrapper *w = stack.top();
delete w;
stack.pop();
}
}
};
Usage example:
std::tuple<size_t, char> doInit(int i, size_t szmin, char c) {
return std::make_tuple(szmin + i, c);
}
int main() {
Container<std::string, size_t, char> cont(&doInit);
cont.init(10, 5, 'x');
std::string* str0 = cont.pop();
std::string* str = cont.pop();
std::cout << *str0 << std::endl;
std::cout << *str << std::endl;
*str0 = "bar";
cont.push(str0);
cont.push(str);
str0 = cont.pop();
str = cont.pop();
std::cout << *str << std::endl;
cont.push(str);
cont.push(str0);
return 0;
}
This correctly outputs:
xxxxxxxxxxxxxx
xxxxxxxxxxxxx
bar
There is still to implement mInfo usage, but it should be a start point...