Allocations don't happen inside constructors (unless the constructor itself again allocates different memory for its own purposes). Constructors are called on memory which has just been allocated.
You're right, it uses variadic templates to forward arguments to the std::shared_ptr constructor, and the allocation (whether it's one or two allocs) happens inside the ctor.
This use case would require a valid copy constructor to work. Without knowing more about jdub's design, it's not possible to say whether that's intended or not. But there are scenarios where it is a completely valid and desired operation, though in this case I doubt it.
So what happens when you have a shared_ptr<T> p, and pass a *p to a make_shared? *p returns a reference, so make_shared passes that reference to the shared_ptr ctor, but there is no ctor that accepts a T&, so wouldn't that be an error too? Or is something else happening that i'm not aware of?
In general constructing two or more shared pointers from the same raw pointers will result in double deletion and as a consequence undefined behavior. Exceptions to this do exist though. boost::intrusive_ptr does not suffer from that problem if the class sticks to the contract. Custom deleters might be able to guarantee defined behavior as well.
Also, if you have a shared_ptr<T> p, and pass it in a function with p.get(), and that function passes the pointer to make_shared, does that mean two separate reference counts will monitor the same pointer? And deleting both shared pointers would cause either a crash or undefined behaviour?
The way jdub uses shared pointers (while still probably not what he intends) does not put him in danger of that though.