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...

You just want to know the supported range? You can use numeric_limits for that.

#include <iostream>
#include <limits>
using namespace std;

int main()
{
    // your code goes here
    std::cout << "Float Range"
       << std::numeric_limits<float>::min() << " / "
       << std::numeric_limits<float>::max() << '\n';
    return 0;
}

As discussed in the comments, std::numeric_limits<float>::min() gives the smallest positive value for a float, while std::numeric_limits<float>::lowest() gives the largest possible negative value, and may be more appropriate. lowest() however is C++11 only.

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

Floating point numbers are stored as an exponent and a fraction within the space available.

For some systems where float is implemented as an IEEE 754 value, the results would looks as below.

sign : 1 bit
exponent : 8 bits
fraction : 23 bits

The exponent allows numbers from 2 ^ (-127) (2 to the power -127) to 2 ^ 128 ( 2 to the power 128).

Allowing a range of numbers from

5.87747E-39 3.40282E+38

the fraction point gives a fraction such as .12313

Thus with 23 bits of values, the accuracy of a number is about 7 decimal digits or 1.19 E-7

For more details see wikipedia : IEEE 754-1985

On a given system, the <cfloat> / <float.h> will give the limits. For non IEEE 754 based representations, you would have to understand how the numbers are stored to calculate the limits.