std::malloc() and starting lifetime of the object

Let me start by a different point of failure in the OP:

 void *p = malloc(sizeof f);

Since it's being compilded as C++ code, this snnipet produces a very common type of UB. Standard C functions may or may not be present in global namespace when standard C++ headers are included. So, the program may or may not compile. Even if it compiles, there's no guarantee that the behavior matches that of either of C or C++ specifications. Preprocessor may act in unpredicted ways. Standard identifiers shared between C and C++, must always be qualified as std::, even if a using directive or declaration has already been introduced:

auto p = std::malloc(sizeof f);
assert(p);

Having solved this not so-obvious problem, let's break the focal point of the question down:

int *q = std::memcpy(p, &f, sizeof f);

AFAIK, the above line always fails at compile-time - due to the simple fact that void* is not implicitly convertible to any other type than its own cv-qualified forms. So, an explicit casting syntax is required. And the simplest working one is static_cast:

auto q = static_cast<int*>
( std::memcpy(p, &f, sizeof f) );

My preference is to automatically deduce the type of result after an explicit cast to avoid repetion and accidental invocation of an extra implicit cast. But that's not a strict rule because of other possibilities for error.

Now I further replace the single-line code above with a roughly equivalent snippet:

std::memcpy(p, &f, sizeof f);
auto q = static_cast<int*>(p);

Because of previously:

 float f = 1.5f;

We know that p points to a valid instance of float which is not a CV-qualified form of int and being a fundamental type, has no inheritance/refinement relationship with int. That means the cast violates strict alaising rule, hence invokes UB.

std::memcpy can only legally circumvent strict alaising for its parameters, but it has a restriction of std::is_trivially_copyable_v<S> on the source, and a std::is_trivially_copyable_v<D> and std::is_trivially_default_constructible_v<D> on its destination; for fundamental types, the above constraints are satisfied by default. The return value is only a copy of the destination pointer.

In order to use the return type as a different implicit life-time type, you need a lifetime cast:

auto q = std::start_lifetime_as<int>
( std::memcpy(p, &f, sizeof f) );

Now q points to in int object, but as long as q is active, p should not be used on the same object.

A simpler approach would be to use a static_cast on std::malloc, before std::memcpy:

auto p = static_cast<int*>
( std::malloc(sizeof f) );
assert(p);
std::memcpy(p, &f, sizeof f);
auto value = *p;

Now it's possible to apply the static_cast to the output of std::memcpy. But what's the point when p had the correct type? The above snippet is correct, because std::malloc is assumed(by the standard) to start the lifetime of implicit life-time types - which covers are fundamental types.

But if all you want is type punning, it's much easier in C++20:

#include <bit>
auto constexpr value = std::bit_cast<int>(1.5f);

The requirements are similar to what was mentioned for source and destination of std::memcpy: source and destination must be trivial types with same size in memory.

As you can see, std::bit_cast can be evaluated at compile-time too. So you don't need an external code generator to compute magic numbers as the bit representation of instances of source type. It's simple, easy to use, and readable. Explicit use of std::mem* functions is not encouraged anymore. This low-level utilities are meant to be buried behind well-tested expertly-written libraries. All their use cases are already covered by other C++ features.

I think the book is correct. The std::malloc doesn't implicitly create a int object because it is returning a void * that is being assigned to a void *. An explicit cast (int *) of the pointer returned by std::malloc and assigning that to an int *, would typically be required in order to implicitly create an int object. Similarly, the std::memcpy would implicitly create a float object at the location pointed to by p, since, p is a void * and the source (f) is a float. Remy Lebeau's comment under the question also discusses this aspect. This behavior of the malloc and the memcpy seems much more plausible than the object that p points to being implicitly created as an int by memcpy in order to avoid UB while dereferencing q, which is a pointer to int that points to the same memory region.

The assignment of the void * returned by std::memcpy to an int * is indeed a syntax error. We can treat it as a minor syntax error maded by the book and not a conceptual error. Thus, let us assume that the statement is of the form, int *q = (int *)std::memcpy(p, &f, sizeof f);.

Now, even though this casting and assignment is allowed, dereferencing q is undefined. This is because of type-accessibility restrictions. As long as the underlying object is of type float, it is UB to access it via a pointer to an integer.