void process(Stream *stream) {
  unique_ptr<char[]> buffer = stream->read();
  if (buffer[0] == FOO)
    process_foo(reinterpret_cast<Foo*>(buffer.get())); // #1
  else
    process_bar(reinterpret_cast<Bar*>(buffer.get())); // #2
}

Modifying a const object through a non-const access path and referring to a volatile object through a non-volatile glvalue results in undefined behavior.

int g=0;

int bar() {
  ++g;
  return g;
}

int foo(const int& a) {
  return a + bar() + a;
}

int main() {
  printf("%i\n", foo(g));
}

И незаряженное ружье один раз в году само стреляет

TB>int g=0;

TB>int bar() {
TB>  ++g;
TB>  return g;
TB>}

TB>int foo(const int& a) {
TB>  return a + bar() + a;
TB>}

TB>int main() {
TB>  printf("%i\n", foo(g));
TB>}
TB>

auto x = a + a;
auto y = bar();
return x + y;

    char buf[100];
    
    int* p = new(buf) int[20] {1,2,3,4};

int foo(const int& a) {
  int ll = a;
  int l = ll + bar();
  return l + a;
}

int foo(int* a, float* b) {
  *a = 8;
  *b = 42.0;
  return *a + 9;
}

There is no concept of left-to-right or right-to-left evaluation in C++. This is not to be confused with left-to-right and right-to-left associativity of operators: the expression a() + b() + c() is parsed as (a() + b()) + c() due to left-to-right associativity of operator+, but c() may be evaluated first, last, or between a() or b() at run time

int bar();

int foo(const int& a) {
  int ll = a;
  int l = ll + bar();
  return l + a;
}

TB>Потому что от желания оптимизатора может поменяться результат функции
TB>Лол это и называется уб

int a = 42;
int b = foo(a, a += 1);

Z3fooRKi:
        movl    (%rdi), %eax
        leal    1(%rax,%rax), %eax
        ret

int bar() {                                                                    
  std::atomic_signal_fence(std::memory_order_acquire);                         
  return 1;                                                                    
}

_Z3fooRKi:
        movl    (%rdi), %edx
        movl    (%rdi), %eax
        leal    1(%rdx,%rax), %eax
        ret

TB>int bar();

TB>int foo(const int& a) {
TB>  int ll = a;
TB>  int l = ll + bar();
TB>  return l + a;
TB>}
TB>

////////////////////////////////////////////////////////
// main.cpp

#include <iostream>

int bar();

int foo(const int& a) {
  int ll = a;
  int l = ll + bar();
  return l + a;
}

int main()
{
   extern int x;

   std::cout << x << std::endl;        // -> 42
   std::cout << foo(x) << std::endl;   // -> 128
   std::cout << x << std::endl;        // -> 43
}

////////////////////////////////////////////////////////
// bar.cpp

int x = 42;

int bar() {
   return ++x;
}

while (*dst++ = *src++);

TB>while (*dst++ = *src++);
TB>

int a, b, c; // глобальные
void foo() {
  b = a;
  c = a;
}

[[aliasing(relaxed)]]
void foo() {
  b = a;
  c = a;
}

void boo(float *a, int n, int *c) {
  for (int i = 0; i < n; ++i) { a[i] *= *c; }
}

boo:
.LFB0:
        testl   %esi, %esi
        jle     .L1
        pxor    %xmm1, %xmm1
        leal    -1(%rsi), %eax
        cvtsi2ssl       (%rdx), %xmm1 <-- Вот тут один раз прочитал и запомнил
        leaq    4(%rdi,%rax,4), %rax
.L3:
        movss   (%rdi), %xmm0
        addq    $4, %rdi
        mulss   %xmm1, %xmm0
        movss   %xmm0, -4(%rdi)
        cmpq    %rax, %rdi
        jne     .L3
.L1:
        ret

boo:
        testl   %esi, %esi
        jle     .L1
        movq    %rdi, %rax
        leal    -1(%rsi), %ecx
        leaq    4(%rdi,%rcx,4), %rcx
.L3:
        movss   (%rax), %xmm0
        mulss   (%rdx), %xmm0 <-- Читает на каждой итерации
        movss   %xmm0, (%rax)
        addq    $4, %rax
        cmpq    %rcx, %rax
        jne     .L3
.L1:
        ret

boo:
        testl   %esi, %esi
        jle     .L1
        movss   (%rdx), %xmm1 <-- Прочли один раз и запомнили
        movq    %rdi, %rax
        leal    -1(%rsi), %edx
        leaq    4(%rdi,%rdx,4), %rdx
.L3:
        movaps  %xmm1, %xmm0
        mulss   (%rax), %xmm0
        movss   %xmm0, (%rax)
        addq    $4, %rax
        cmpq    %rdx, %rax
        jne     .L3
.L1:
        ret

Типа передали константную ссылку — значит компилятор вправе предполагать что содержимое не меняется!

foo(&src);
while(*dst++=*src++);

TB>foo(&src);
TB>while(*dst++=*src++);
TB>

foo(&src);
while(*dst++=*src++);
bar();

alignas(T) char buf[sizeof(T)];
T* obj = (T*)buf;

// placement new не нужен, потому что T у нас implicitly created
setup_something(obj);
process_something(obj);
write_some_data(buf);

std::destroy_at(obj);
// obj умер

read_some_data(buf);
// obj снова жив?
// или нужно явно сделать
obj = (T*)buf;

process_something(obj);

int const x[1];

int const_x[1];

[memory          , npages] data вся достпная память программе
[memory+delta_ro , npages] замаплено на data только чтение (запись игнорируется)
[memory+delta_we , npages] тоже замаплено на data только вызывает исключение при попытке записи
[memory+delta_na , npages] при любом обращении вызывает исключение

enum class E;

template<template<class A> class B, class C&, E>
void foo();

struct S {
    const int i;
};

void bar(const S& s);

int foo() {
    const S s{1};
    int i1 = s.i;
    bar(s);
    int i2 = s.i;
    return i1 + i2;
}

mov     eax, DWORD PTR [rsp+12]

TB>struct S {
TB>    const int i;
TB>};

TB>void bar(const S& s);

TB>int foo() {
TB>    const S s{1};
TB>    int i1 = s.i;
TB>    bar(s);
TB>    int i2 = s.i;
TB>    return i1 + i2;
TB>}
TB>

TB>mov     eax, DWORD PTR [rsp+12]
TB>

        pushq   %rax
        movl    $1, (%rsp)
        movq    %rsp, %rdi
        callq   bar(S const&)@PLT
        movl    $2, %eax
        popq    %rcx
        retq

A const object is an object of type const T or a non-mutable subobject of a const object.

Except for array types, a compound type ([basic.compound]) is not cv-qualified by the cv-qualifiers (if any) of the types from which it is compounded.

Any attempt to modify ([expr.ass], [expr.post.incr], [expr.pre.incr]) a const object (basic.type.qualifier) during its lifetime ([basic.life]) results in undefined behavior.