Help me with C++ template function

[sasho648]

I want to make my own allocating function which call the constructor for each object but I have problems here I is my code:

template<class T>
T* MyAllocHeap(unsigned long size, const T& ObjTmpl, bool bSave) {
    T* Obj=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size*sizeof(T));
    if(bSave)
    for(unsigned long cr(0); cr<size; ++cr)
        memcpy(&Obj[cr], &ObjTmpl, sizeof(T));
    return Obj;
}

I realize this code isn't very effective cause I just copy one static object and if in this object is allocated memory there'll be leaks:

class My{
    My() { Obj=new classEx; }
    classEx* Obj;
} ;
MyAllocHeap<My>(1, My(), 1);

My function need to be something like this but It didn't compile:

template<class T>
T* MyAllocHeap(unsigned long size, T (*ObjTmplFunc)(...), bool bSave, ... /*funct argum*/)) {
    T* Obj=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size*sizeof(T));
    if(bSave)
    for(unsigned long cr(0); cr<size; ++cr)
        Obj[cr].ObjTmplFunc(args), &ObjTmpl, sizeof(T));
    return Obj;
}

[/code]
Can you help me with function like this but working with c++ ?

[o1vk4iN6]

operator new( size * sizeof( T ) );

To allocate memory without calling the constructor of a class.

void* ptr;
class MyObject;

new( ptr ) MyObject();

Constructors MyObject at ptr.

Also you shouldn't "save" a class by using memcpy, that would create a shallow copy, you should instead use the copy constructor.

[sasho648]

Maybe you don't understand me - I want to make, my allocate function, to call a specific constructor function, passed with the arguments, on every object.
Not using the new operator.

EDIT: Actually I want to allocate the memory for my objects and then call them constructor.

[JLBorges]

> Actually I want to allocate the memory for my objects and then call them constructor.

This would be the general idea:

#include <memory>
#include <cstdlib>
#include <new>
#include <iostream>

template < typename T > void delete_object( T* p )
{
    p->T::~T() ; // destroy the object
    std::free(p) ; // and free its memory
}

template< typename T, typename... CONSTRUCTOR_ARGS >
std::shared_ptr<T> make_object( CONSTRUCTOR_ARGS... constructor_args )
{
     void* p = std::malloc( sizeof(T) ) ; // allocate memory
     // construct with a placement new
     return std::shared_ptr<T>( ::new (p) T( constructor_args... ), delete_object<T> ) ;
}

struct A
{
    A() { std::cout << "A::default constructor\n" ; }
    explicit A( int, int=6 ) { std::cout << "A::A( int, int )\n" ; }
    A( const A& ) { std::cout << "A::copy constructor\n" ; }

    ~A() { std::cout << "A::destructor\n" ; }
};

struct B
{
   B( const char*, double ) { std::cout << "B::B( const char*, double )\n" ; }
   ~B() { std::cout << "B::destructor\n" ; }
};

int main()
{
    std::shared_ptr<A> a1 = make_object<A>() ;
    std::shared_ptr<A> a2 = make_object<A>(12) ;
    std::shared_ptr<A> a3 = make_object<A>(12, 30 ) ;
    std::shared_ptr<A> a4 = make_object<A>(*a1) ;

    std::shared_ptr<B> b = make_object<B>( "hello world!", 1234.567 ) ;
}

In practice, you would want to write an allocator of your own and then just use std::allocate_shared<>()
http://en.cppreference.com/w/cpp/memory/shared_ptr/allocate_shared

[sasho648]

Thanks for giving me that new information for me. I was never heard about this before but I'll read some articles. I'll mark this thread as a solved now.