How is c++ automatically deciding that a variable is being stored as subnormal in this program?

I am learning c++ and I am really trying to get a handle on how numbers are stored and manipulated in memory. To help test my understanding, I wrote the following program:

#include <iostream>
#include <cmath>

int main () {
    int answer = 200*300*400*500;

    std::cout << "int result: " << answer << std::endl;
    std::cout << "Size of int result: " << sizeof(answer) << std::endl;
    std::cout << "Is normal? " << isnormal(answer) << std::endl;

    float f_answer = 200.0*300*400*500;

    std::cout << "float result: " << f_answer << std::endl;
    std::cout << "Size of float result: " << sizeof(f_answer) << std::endl;
    std::cout << "Is normal? " << isnormal(f_answer) << std::endl;

    float under = 0.0000000005 * 0.0000000001 * 0.0000000001 * 0.0000000001 * 0.00001;
    std::cout << "under result: " << under << std::endl;
    std::cout << "Is normal?: " << isnormal(under) << std::endl;

    return 0;
}

Based on everything that I have been learning about IEEE I was expecting the last block to return an underflow value (or 0) because it was my understanding that the most precise that 32bit floats can be is around e^-38.

To my surprise, I was able to get it all the way down to e^-45! This made me start to look into normal vs. subnormal. So, awesome...something, somewhere is figuring out that I want more precision and deciding that this variable should be stored as subnormal. My question is: how?? What is doing this? Is this c++ itself?? Is it the compiler? (I'm using clang, to the best of my knowledge.) I thought the major benefit of using a language like this is that I can be pretty damn sure of what it's doing when I tell it to save as a float. My apologies if this is an ill-formed question, this is truly my first foray into lower level languages and any clarification that folks can provide would be greatly appreciated!

A number, other than zero, is subnormal if its magnitude is below the normal range of the floating-point format.

The format commonly used for float is IEEE-754 binary32, also called single-precision. In this format, finite numbers are represented as ±2^e*f, where e is an integer satisfying −126 ≤ e ≤ 127 and f is the number represented by a 24-bit binary numeral of the form d.ddddddddddddddddddddddd₂, where each d represents a bit.

For all the normal numbers, the first d is 1, so the numeral has the form 1.ddddddddddddddddddddddd₂, and f satisfies 1 ≤ f < 2. The smallest normal number is +2⁻¹²⁶•1.00000000000000000000000₂, which is approximately 1.1755•10⁻³⁸. The largest representable finite number is +2¹²⁷•1.11111111111111111111111₂, which is approximately 3.40282•10³⁸.

For the subnormal numbers, the first d is 0, and e is −126. The largest subnormal number is +2⁻¹²⁶•0.11111111111111111111111₂, so it is slightly less than the smallest normal number. The smallest subnormal number is +2⁻¹²⁶•0.00000000000000000000001₂, which is approximately 1.40130•10⁻⁴⁵.

To encode floating-point representations in 32 bits, the first bit is 0 for + and 1 for −. For normal numbers, the next eight bits are the binary for e+127, so they are a value from 1 to 254, inclusive. The remaining 23 bits are the 23 d bits after the “.”. The first bit for f is known to be 1 when the exponent code is 1 to 254.

For subnormal numbers, the eight bits after the sign bit are 0, and the remaining 23 bits are the 23 d bits after the “.”. The first bit for f is known to be 0 when the exponent code is 0.

The exponent code 255 is used to represent infinities and NaNs (meaning Not a Number).