I know that templatized types such as the below cost nothing on the compiled binary size:

```
template<auto value>
struct ValueHolder{};

```

I'm making a program that will use a LOT of such wrapped types, and I don't think I want to be using `integral_constant`s for that reason, since they have a `::value` member. I can get away with something more like:

```
template<typename ValHolder>
struct Deducer;

template<auto value>
struct Deducer<ValueHolder<value>> {
    using Output = ValueHolder<value+1>;
};

```

But it's definitely a bit more work, so I want to make sure I'm not doing it for nothing. Note that we're talking TONS of such values (I'd explain, but I don't want to go on too far a tangent; I'd probably get more comments about "should I do the project" than the question!).

So the question is: Do [static] constexpr values take any size at all in the compiled binary, or are the values substituted at compile-time, as if they were typed-in literally? I'm pretty sure they DO take size in the binary, but I'm not positive.

I did a little test at `godbolt` to look at the assembly of a constexpr vs non-constexpr array side-by-side, and everything looked pretty similar to me: <https://godbolt.org/z/9hecfq>

```
int main()
{
    // Non-constexpr large array
    size_t arr[0xFFFF] = {};

    // Constexpr large array
    constexpr size_t cArr[0xFFF] = {};

    // Just to avoid unused variable optimizations / warnings
    cout << arr[0] << cArr[0] << endl;
    return 0;
}

```