C++ check if const qualified variables are the same object at compile-time

I am working on a project that uses some compile-time logic based on whether two arguments are the same object (i.e. same memory address). The following is a simplified example that compiles and runs as hoped on my machine with c++20 standard and GNU compiler:

#include <iostream>

template <typename T1, typename T2>
consteval bool is_same_object(T1 const& a, T2 const& b) 
{return &a == &b;}

int main()
{
    const int x(1),y(1);

    std::cout << is_same_object(x, y) << std::endl; // Should print 0 (false)
    std::cout << is_same_object(x, x) << std::endl; // Should print 1 (true)

    return 0;
}

Because memory addresses are typically assigned at runtime (to the best of my knowledge), I am unsure if this design pattern will be portable and robust. Will this comparison reliably work or are there better ways of accomplishing this? What restrictions should one be aware of when using such comparisons for template metaprogramming?

So to summarize several comments and to add some more details:
No, your code will not relyably work.

Short answer:
What will work as expected is:

• Variables of the same type and different values will always have different addresses (this should be obvious).
• Addresses of non-constant variables of the same type which are processed individually will always have different addresses, even when they temporarily have the same value.
• Different variables of the same type where at least one is marked as volatile will have different adresses

What may not work as expected is:

• Addresses of different constant variables with the same value
• Addresses of the same variable content interpreted as different types, e.g. as base types

Detailed anser:

• A compiler can choose to merge different constant variables with the same values into one, thus let them use the same address. I assume the compiler can also mark anything as constant which is never modified, which makes this whole point even more unpredictable. Edit: Sorry, this is not true. Apparently a conforming compiler is not allowed to do this.
• In cases of multiple inheritance (not completely sure about pure virtual interfaces), casting a class to different base classes can result in different addresses, even though they belong to the same instance
• Taking the address of the first field of a structure can (if there is no vtable) report the same address as the address of the entire structure. In this case is a bit questionable what the logical expectation is, the two instances are at least partially the same.
• Very unlikely on a known code base but just to be complete: Classes with a custom operator& can behave different

Side note:
Remember that the final code does not run as C++, but as assembler code and that some C++ variables may never occupy any address.
Assembler code performs the computations in registers and uses the addresses mainly to load or save information. For some simple constant numeric values it can be possible to load the content directly from the assembler code into the register without the need of a RAM address.
Also for local variables it can be possible that they are optimized out so that they only appear temporarily in a register and never require a RAM address.
Of course, when you write code which operates on addresses then such optimizations won't happen, so your code is not affected by this.