A 32 bit floating point number has 23 + 1 bits of mantissa and an 8 bit exponent (-126 to 127 is used though) so the largest number you can represent is:

(1 + 1 / 2 + ... 1 / (2 ^ 23)) * (2 ^ 127) = 
(2 ^ 23 + 2 ^ 23 + .... 1) * (2 ^ (127 - 23)) = 
(2 ^ 24 - 1) * (2 ^ 104) ~= 3.4e38

C does not define float as described by OP. The one suggested by OP: binary32, the most popular, is one of many conforming formats.

What C does define

5.2.4.2.2 Characteristics of floating types

s sign (±1)
b base or radix of exponent representation (an integer > 1)
e exponent (an integer between a minimum emin and a maximum emax)
p precision (the number of base-b digits in the significand)
fk nonnegative integers less than b (the significand digits)

x = s*power(b,e)*Σ(k=1, p, f[k]*power(b,-k))

For binary32, the max value is

x = (+1)*power(2, 128)*(0.1111111111 1111111111 1111 binary)

x = 3.402...e+38

Given 32-bits to define a float many other possibilities occur. Example: A float could exist just like binary32, yet not support infinity/not-a-number. The leaves another exponent available numbers. The max value is then 2*3.402...e+38.

binary32 describes its significand ranging up to 1.11111... binary. The C characteristic formula above ranges up to 0.111111...

See Single-precision floating-point format for a details about a typical C float.

Range of magnitude for float in c programming language?

#include <float.h>
printf("float magnitude range %e to %e\n", FLT_MIN, FLT_MAX);
// typical result
// float magnitude range 1.175494e-38 to 3.402823e+38

How is that possible since we have only 32-bits?

Typical float does indeed only store about 2³² different values. Yet they are not distributed linearly but logarithmically in linear groups.

2²³ different values in the range [2^-126 to 2^-127)
...
2²³ different values in the range [0.5 to 1.0)
2²³ different values in the range [1.0 to 2.0)
2²³ different values in the range [2.0 to 4.0)
...
2²³ different values in the range [2¹²⁷ to 2¹²⁸)

And their negative counter parts.
Also +/- zeros, small sub-normal numbers, +/- infinity and Not-a-Number

It also has to keep track of the sign , so how is it storing all this in just 32-bits?

 1 bit for sign
 8 bits for the binary exponent
23 bits for the significant (with a MSBit usually implied as 1)
--
32 bits

When printing a float, only about 6 or so (FLT_DIG, FLT_DECIMAL_DIG) significant digits usually are important.

printf("%.*e\n", FLT_DIG-1, FLT_TRUE_MIN);
printf("%.*e\n", FLT_DIG-1, FLT_MIN);
printf("%.*e\n", FLT_DIG-1, acos(-1));
printf("%.*e\n", FLT_DECIMAL_DIG - 1, nextafterf(FLT_MAX, 0.0));
printf("%.*e\n", FLT_DECIMAL_DIG - 1, FLT_MAX);

Output

1.40130e-45    // min sub-normal
1.17549e-38    // min normal
3.14159e+00    // pi
3.40282326e+38 // number before max
3.40282347e+38 // max