Какова область буквального значения и как компилятор выделяет для него память?

OK Плохой пример в вопросе.
Но вопрос по-прежнему актуален:
Давайте попробуем:

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.

Как компилятор выделяет память для временного объекта?

Неопределено до компилятора.
_{Но было бы очень просто выделить немного больше памяти на кадр стека и удерживать ее там. Затем уничтожьте его и уменьшите размер кадра стека (хотя в этом ответе делается много предположений о базовом оборудовании, чего вам никогда не следует делать (лучше просто думать об этом как о магии компилятора)).}

Какова область действия временного объекта?

Временный объект живет до конца выражения (обычно ;), если только он не привязан к константной ссылке. Если он привязан к константной ссылке, то он живет до конца области, к которой относится ссылка (с некоторыми исключениями (например, конструкторами)).

Почему мы не можем получить его адрес с &12 в области видимости?

В вопросе 12 нет временного объекта.
Это целочисленный литерал.

В вашем примере 12 является целочисленным литералом. Целочисленные литералы почти всегда «встроены» в машинные инструкции как непосредственный операнд. Они не хранятся в памяти, поэтому вы не можете получить к ним доступ через адрес и адрес, и у них нет области действия.

int x = 12 

переведет на что-то вроде

movl 12 address_of_x_or_register

практически во всех архитектурах. Здесь 12 закодировано как часть инструкции.

Просто чтобы было ясно, x все еще находится в памяти (стеке в случае локальных переменных или сегменте данных в случае глобальных переменных) и в конечном итоге будет содержать значение 12. «Объект» RHS 12 представляет собой целочисленный литерал и не находится в памяти до или во время инструкции, а «находится» в самой инструкции.

1. How does the compiler allocate memory to a temporary object?

string myString = "hello";

В этом случае вызывается conversion constructor для инициализации нового объекта.

2. What is the scope of a temporary object?

Срок жизни временного объекта до точки с запятой

3. Why can't we get its address with an &12 in its scope? (in this case "hello")

&12 не является объектом, это параметр, передаваемый конструктору преобразования

Итак, во время компиляции что компилятор делает с ним? Хранилище?

Это действительно трудно ответить. Компилятор максимально оптимизирует код (объем или уровень выполняемой оптимизации часто можно установить в вашем инструменте компилятора).

Для примера, подобного приведенному, если x можно заменить в инструкциях по сборке на 12, тогда x «оптимизируется», и 12 используется как прямая замена x.

Ключевое слово volatile можно использовать, чтобы заставить компилятор проверять x каждый раз, когда он используется в коде. Это создаст большие программы, но может быть полезно, чтобы помочь вам назначить место в памяти (хранилище) для вашей переменной.

Объект - это "что-то в памяти". Это означает, что это что-то занимает часть адресного пространства процесса (либо в стеке, либо в «свободной» памяти). Также это означает, что вы можете получить его адрес, если хотите.

Временные объекты — это просто объекты. Компилятор генерирует код для их создания, если ему нужны такие объекты для вычисления выражения:

void f(const string&);

void g()
{
     f(string("Hello"));
}

Выражение, которое вызывает f(), приведет к генерации кода, который:

• создает временный строковый объект. Конструктор вызывается с параметром const char*;
• вызывает f() со ссылкой на этот временный объект в качестве параметра;
• уничтожает временный строковый объект.

Ключевой частью этого является уничтожение временного объекта в конце оценки выражения. Временный объект существует только в самом выражении (это их импровизированная область). Вы можете попробовать что-то вроде: const string* ps = &string("Hello") но ваш компилятор, вероятно, забьет тревогу, потому что такое выражение приведет к созданию указателя, который ссылается на память, которая была занята временным объектом, но больше им не занята. Он может по-прежнему содержать элементы строкового объекта или может быть перезаписан следующими выражениями в программе (не говоря уже о том, что уничтожение временного объекта освободит память, выделенную объектом в куче). Использование ps приведет к неопределенному поведению.

Другой вопрос, который здесь возникает, касается природы объектов в таком выражении, как int x = 12. В этом случае x может быть объектом или может не быть. Это зависит от настроек компилятора и кода, следующего за строкой. Компилятор может решить поместить x в регистр. В таком случае x не будет объектом, потому что регистры не имеют адресов (по крайней мере, на большинстве платформ). Если вы не измените значение x, компилятор может даже захотеть использовать 12 напрямую в инструкциях. Таким образом, «12» будет существовать только как часть кодов инструкций.

В любом случае, что бы ни происходило в следующем коде, int x = 12 не создаст временный объект 12. Если компилятор решит разместить в памяти 12, инструкция будет выглядеть так (псевдокод):

store immediate address_of_x, 12

В случае x, помещенного в регистр, вы будете иметь:

move immediate regX, 12

В обоих случаях 12 будет частью инструкции (фрагмента скомпилированного кода). Таким образом, это не будет отдельным объектом.

Будьте осторожны, так как другие ответы в основном развеяли ваши заблуждения, но не этот:

Какова область видимости литералов?

Этот вопрос не имеет смысла, так как область действия является свойством имен (имена переменных, имена функций, имена типов, имена шаблонов, имена пространств имен...).

Литерал — это обозначение числа, а не имени.