您可以使用浮点平方根的结果作为提示。将其转换为整数。检查平方是否相等。如果它更高或更低，则递减或递增它，然后重新检查平方，并继续，直到您将参数绑定为：c1c1〈= n〈=（c1+1）（c1+1）

你可以使用std：：sqrt作为猜测和乘法测试：

#include <cmath>
#include <limits>
#include <iostream>

bool isPerfectSquare(long long n){
    double guess = sqrt(n);
    long long r = std::floor(guess);
    if(r*r == n) return true;
    else {
        r = std::ceil(guess);
        return r*r == n;
    }
}

int main() {
    const long long Limit = std::pow(10, std::numeric_limits<long long>::digits10 / 2);
    std::cout << " Limit: " << Limit << '\n';
    for (long long i = 0; i < Limit; ++i) {
        if( ! isPerfectSquare(i*i)) {
            std::cout << "Failure: " << i << '\n';
            return 0;
        }
    }
    std::cout << "Success\n";
}

您使用round。

bool isPerfectSquare(long long n) {
    long long squareRootN = (long long)round((sqrt(n)));
    
    if(squareRootN * squareRootN == n) {
        return true; 
    } else {
        return false; 
    }
}

round将数字四舍五入到最近的四舍五入。只有当n是完全平方时，该函数才为真。

mmmm不要使用float/double作为true/false的结果（你最终会遇到近似问题）更好的是整数方法：

boolean is_square(long long n)
   {
      long long a=n;
      while (a*a>n)
      {
         a=div(a+div(n,a),2);
      }
      return a*a==n;
   }

div（）是不带余数的整数除法（您可以在某些方面使用GCD（））
我知道，我知道……一定要注意溢出的问题

Sqrt（4）可以返回1.9999
不，4和2完全可以表示为二进制浮点数。没有精度问题。
问题是long long有64位的精度，但double只有52位，所以所有依赖于调用sqrt(double)的解决方案都会在达到这个限制时开始失败。下面是一个简单的测试程序：

#include <iostream>
#include <math.h>
#include <stdlib.h>

bool isPerfectSquare(long long n)
{
    double root = sqrt(n);
    return floor(root) == root;
}

void check(long long x)
{
    if (!isPerfectSquare(x))
        std::cerr << x << " should be perfect\n", exit(1);
    if (isPerfectSquare(x-1))
        std::cerr << x-1 << " should NOT be perfect\n", exit(1);
    if (isPerfectSquare(x+1))
        std::cerr << x+1 << " should NOT be perfect\n", exit(1);
}

int main()
{
    for (long long i = 2; i < 3037000499; ++i)
        check(i * i);
    std::cout << "all tests passed\n";
}

这是我电脑上的输出：

4503599627370497 should NOT be perfect

注意log(4503599627370497)/log(2) = 52。如果你不关心那么大的数字，你可以使用简单的解决方案，只检查sqrt是否返回整数结果。

您可以简单地检查sqrt()的下限和上限：

bool isSquare (long long number)
{
    double root = sqrt(number);
    double floor = std::floor(root);
    double ceil = std::ceil(root);

    return (floor * floor == number) && (ceil * ceil == number);
}

你可以使用一个范围作为你的返回布尔值，尽管它可能会导致不精确的输出，这取决于你的要求有多严格：

double threshold = 0.01;

return (squareRootN*squareRootN > n-threshold) && (squareRootN*squareRootN < n+threshold);

密码没问题！
我花时间写了一个小测试。由于输入范围有限，我们可以简单地验证每个输入的函数。
请注意，我确实必须为sqrt函数添加一个显式强制转换，以便编译（使用MS VC++ 10）。

#include <math.h>
#include <iostream>
#include <set>

bool isPerfectSquare(long long n){
    long long squareRootN=(long long)(sqrt((double)n)+0.5);

    return squareRootN*squareRootN == n;
}

int main()
{
    // for the input range,
    // generate a set with numbers that are known to be perfect squares.
    // all the rest are not.
    std::set<long long> perfectSquares;
    for(long long i = 1ll; i <= 100000ll; ++i) {
        perfectSquares.insert(i*i);
    }
    std::cout << "Created lookup." << std::endl;

    // now test the function for all the numbers in the input range   
    int progress = -1;
    for(long long i = 1ll; i <= 10000000000ll; ++i) {
        bool expected = (perfectSquares.count(i) == 1);
        bool actual = isPerfectSquare(i);

        if(expected != actual) {
            std::cout << "Failed for " << i << std::endl;
        }

        int newprogress = i / 100000000ll;
        if(newprogress != progress) {
            progress = newprogress;
            std::cout << "Progress " << progress << "%" << std::endl;
        }
    }
    std::cout << "Test finished." << std::endl;
}

结果？所有值都通过！问题一定出在使用函数的代码中。也许可以给函数添加输入范围验证。

long long是一个整数类型。因此，您的+0.5在截断时丢失。