Question

int x = 12;

12 is said to be integer literal, and therefore can’t be used in the LValue.

1. How does the compiler allocate memory to a literals?
2. What is the scope of a literals?
3. Why can’t we get its address with an &12 in its scope?

Answer 1

OK Bad example in the question.
But the question is still valid:
Lets try:

Foo getFoo() {return Foo();}

int func()
{
    getFoo().bar();   // Creates temporary.
    // before this comment it is also destroyed.
    // But it lives for the whole expression above
    // So you can call bar() on it.
}

int func2()
{
    Foo const& tmp = getFoo();  // Creates temporary.
                                // Does not die here as it is bound to a const reference.

    DO STUFF
}  // tmp goes out of scope and temporary object destroyed.
   // It lives to here because it is bound to a const reference.

How does the compiler allocate memory to a temporary object?

Undefined up-to the compiler.
_{But it would be real easy to allocate a tiny bit more memory onto the stack frame and hold it there. Then destroy it and reduce the size of the stack frame (though this answer makes a whole lot of assumptions about the underlying hardware that you should never do (best just to think of it as the compiler doing magic)).}

What is the scope of a temporary object?

The temporary object lives until the end of the expression (usually the ;) unless it is bound to a const reference. If it is bound to a const reference then it lives to then end of the scope that the reference belongs too (with a few exceptions (like constructors)).

Why can’t we get its address with an &12 in its scope?

In the question 12 is not a temporay object.
It is an integer literal.