C++ sqrt: square root with std::sqrt and cmath

std::sqrt in C++ returns the square root of a number: std::sqrt(25.0) is 5. Include <cmath> to use it. Given an int, it returns a double, and given a negative number it returns NaN, “not a number”, which you test for with std::isnan. For a cube root, call std::cbrt.

A whole program that prints two square roots:

#include <cmath>
#include <iostream>

int main() {
    std::cout << std::sqrt(25.0) << '\n';  // 5
    std::cout << std::sqrt(2.0) << '\n';   // 1.41421
}

It printed:

5
1.41421

The first result is the double 5.0, which std::cout printed as 5, and it printed six digits of the second. The samples are C++17, built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++). All four printed the same numbers; only the spelling of NaN differed. Since When lists, for each standard, the first compiler releases that support it.

What does sqrt return for an int, a float or a double?

For a float the sqrt function returns a float, and for a double a double. A whole number such as an int is treated as a double first (the standard’s <cmath> synopsis), so std::sqrt(10) returns a double as well. The samples checked each type with std::is_same_v, which is true when two types are the same:

auto from_float = std::sqrt(2.0f);
auto from_double = std::sqrt(2.0);
auto from_int = std::sqrt(10);  // 10 becomes 10.0 first

std::cout << std::boolalpha;
std::cout << std::is_same_v<decltype(from_float), float> << '\n';
std::cout << std::is_same_v<decltype(from_double), double> << '\n';
std::cout << std::is_same_v<decltype(from_int), double> << '\n';
std::cout << from_int << '\n';  // 3.16228

int root = std::sqrt(10);  // the decimals are cut off
std::cout << root << '\n';  // 3

All four printed true three times, then 3.16228 and 3. Storing the result in an int cuts the decimals off: 3.16228 became 3. Only MSVC warned (C4244 at /W4); GCC and both Clangs were silent at -Wall -Wextra. What an int and a double can each hold is in C++ data types.

What does sqrt of a negative number return?

NaN, a special value a double or a float can hold, meaning “not a number”. The program does not stop and no exception is thrown, so test the result with std::isnan, which returns true for a NaN. Better still, check the number before the call, so a negative one never reaches std::sqrt:

double root = std::sqrt(-4.0);
std::cout << root << '\n';  // NaN, spelled by the library

std::cout << std::boolalpha;
std::cout << std::isnan(root) << '\n';  // true

double x = -4.0;
if (x < 0) {
    std::cout << "no real square root\n";
} else {
    std::cout << std::sqrt(x) << '\n';
}

On Windows, MSVC and Clang 19.1 (both on Microsoft’s library) printed:

-nan(ind)
true
no real square root

GCC 16.2 and Clang 23.1 with libc++, both on Linux, printed -nan on the first line. The spelling belongs to the standard library, so never compare the printed text: call std::isnan.

How do you check for a perfect square in C++?

Take the square root, round it to the nearest whole number with std::lround, square that, and compare it with the number:

bool is_perfect_square(int n) {
    if (n < 0) {
        return false;  // no negative number is a square
    }
    long long root = std::lround(std::sqrt(n));  // nearest whole
    return root * root == n;
}

int main() {
    std::cout << std::boolalpha;
    std::cout << is_perfect_square(49) << '\n';          // true
    std::cout << is_perfect_square(50) << '\n';          // false
    std::cout << is_perfect_square(2147395600) << '\n';  // true
}

All four printed true, false and true. The rounded root goes in a long long because from 2,147,441,941 up it rounds to 46,341, whose square is too big for a 4-byte long, the type std::lround returns on Windows.

2,147,395,600 is 46,340 squared, the largest square a 4-byte int holds. The samples also ran the function over every square from 1 up to that one, 46,340 of them, and over each of them plus one: it answered correctly every time, on all four.

Should you use sqrt or pow(x, 0.5)?

Use std::sqrt: it says what it does. std::pow with an exponent of 0.5 is also a square root, and in the samples it gave exactly the same double:

double by_sqrt = std::sqrt(x);
double by_pow = std::pow(x, 0.5);
// ...
std::cout << (by_sqrt == by_pow) << '\n';

Printed with 17 significant digits, set with std::setprecision(17) as in formatting numbers with cout, and with std::boolalpha, all four gave for 2.0:

1.4142135623730951
1.4142135623730951
true

For 10.0 and 1e300 the two were equal too. That is what these builds did, not a promise: the IEEE floating-point standard requires std::sqrt to be correctly rounded, exact whenever the root can be held exactly in a double, and std::pow is “not so constrained” (cppreference on std::sqrt).

How do you take a cube root or another root?

Call std::cbrt for a cube root and std::pow(x, 1.0 / n) for the n-th root. Write 1.0, not 1: with an int n, 1 / n divides two whole numbers and gives 0, so std::pow(81.0, 1 / n) printed 1 on all four. For the long side of a right triangle, such as the diagonal of a 3 by 4 rectangle, std::hypot takes the two sides:

std::cout << std::cbrt(27.0) << '\n';          // 3
std::cout << std::cbrt(-8.0) << '\n';          // -2
std::cout << std::pow(81.0, 1.0 / 4) << '\n';  // 3
std::cout << std::hypot(3.0, 4.0) << '\n';     // 5

All four printed 3, -2, 3 and 5. std::cbrt accepts a negative number. std::pow with a negative base and a fractional exponent, such as 1.0 / 3, returns NaN instead, so take the cube root of a negative number with std::cbrt. std::hypot squares the sides for you, without undue overflow along the way, and since C++17 it takes a third argument, for a distance in three dimensions.

How do you find a square root without sqrt?

With Newton’s method: start from a guess, then replace it, round after round, with the average of the guess and the number divided by the guess:

double x = 2.0;
double guess = 1.0;  // any positive start works
std::cout << std::setprecision(10);
for (int round = 1; round <= 6; ++round) {
    guess = (guess + x / guess) / 2;  // average of guess and x/guess
    std::cout << guess << '\n';
}
std::cout << std::sqrt(x) << '\n';

It printed:

1.5
1.416666667
1.414215686
1.414213562
1.414213562
1.414213562
1.414213562

The fourth round already printed 1.414213562, the same ten digits as std::sqrt(2.0) on the last line, and rounds five and six changed nothing at that precision. It makes a good exercise; in code you ship, call std::sqrt.

Which function for which root?

Standard library has the rest of the library’s answers.