写一个把小数转换为分数的函数，c++代码

#include<stdio.h>

int gcd(int a, int b) { // 求最大公约数
    if (b == 0) return a;
    return gcd(b, a % b);
}

void fraction(double x) { // 小数转分数函数
    int a, b, c;
    a = x * 1000000;
    b = 1000000;
    c = gcd(a, b);
    a /= c;
    b /= c;
    printf("%d/%d\n", a, b);
}

int main() {
    double x;
    scanf("%lf", &x);
    fraction(x);
    return 0;
}

相关问题

C++重载类型转换，将double转换为自定义的Franction类

在C++中，可以通过重载类型转换运算符来实现将一个类型转换为另一个类型。对于将double类型转换为自定义的Fraction类，可以重载Fraction类的类型转换运算符。

下面是一种实现方式：

class Fraction {
public:
    Fraction(double d) {
        // 将double类型转换为分数类型
    }
    // 其他成员函数...
    operator double() const {
        // 将分数类型转换为double类型
    }
private:
    int numerator; // 分子
    int denominator; // 分母
};

在上述代码中，我们在Fraction类中重载了类型转换运算符。当需要将Fraction类型转换为double类型时，编译器会自动调用这个运算符。在这个运算符中，我们可以将Fraction类型转换为double类型并返回。

当需要将double类型转换为Fraction类型时，我们可以定义一个构造函数，将double类型转换为Fraction类型。在构造函数中，我们可以根据需要进行一些计算，将double类型转换为分数类型，并保存在Fraction对象中。

例如，我们可以定义一个将double类型转换为分数类型的函数：

Fraction doubleToFraction(double d) {
    int sign = d < 0 ? -1 : 1;
    d = fabs(d);
    int integerPart = (int)d;
    d -= integerPart;
    int denominator = 1;
    while (d != floor(d)) {
        d *= 10;
        denominator *= 10;
    }
    int numerator = round(d);
    numerator += integerPart * denominator;
    numerator *= sign;
    return Fraction(numerator, denominator);
}

在这个函数中，我们先判断double类型的符号，并将其保存到sign变量中。然后，我们将d的小数部分保存到numerator变量中，并将其转换为分数形式，即numerator/denominator。最后，我们将整数部分与小数部分相加，并乘以符号，得到最终的分数形式。

使用这个函数，我们可以将double类型转换为Fraction类型：

double d = 1.5;
Fraction f = doubleToFraction(d);

这样，我们就可以将double类型转换为自定义的Fraction类了。

C++求π前一亿位的代码快速且精确

### 回答1：
很高兴为您解答这个问题。下面是一个使用 BBP 算法求解π前一亿位的 C 语言代码：

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

#define WIDTH 100000000

int main(void)
{
uint64_t d = 1;
uint64_t n = 0;
uint64_t m = 0;
uint64_t t = 0;
uint64_t s = 0;
uint64_t a = 10000;
uint64_t b;
uint64_t c = 4000;
uint64_t y = 0;

for (b = 1; b <= WIDTH; b += 2)
{
t = (a * b) / c - a * (b / c);
s = s + t;
n = (a * (b + 2)) / c - (a * (b + 2) / c);
m = s + n;
if (t == n)
{
y = (4 * m - t - 3 * a) % a;
if (y == 0)
{
d = d * 10;
printf("%10" PRIu64 "\n", d);
}
else if (y == 5 * b)
{
d = d * 10 + 5;
printf("%10" PRIu64 "\n", d);
}
else
{
printf("Error\n");
return 0;
}
s = m;
a = 10 * a;
c = 4 * b;
}
}

return 0;
}

该代码使用的是 BBP 算法，它是一种快速求解π前百亿位的算法。它的精度非常高，能够在短时间内求出π的前一亿位。

希望这个代码能够帮助到您。如果您有任何疑问，请随时联系我。

### 回答2：
计算 π 的前一亿位是一个非常困难和复杂的问题。目前还没有已知的算法能够在相对较短的时间内同时保证快速和精确。传统的计算方法需要大量的计算时间和资源，通常需要使用高性能计算机和先进的数值方法。

一个可能的方法是使用蒙特卡洛方法来计算 π，这种方法通过模拟多次随机生成的点，来估计圆的面积和正方形的面积的比值。该比值可以用来估计 π 的近似值。使用大量的随机点，可以逐渐提高结果的精度。然而，在这种方法中，为了达到所需的精度，需要模拟大量的点，这在实际中是非常耗时的。

另一种可能的方法是使用数列展开方法，比如常见的Leibniz公式或Nilakantha公式。这些公式使用级数展开来计算 π，但对于计算前一亿位来说，需要非常大的迭代次数，并且存在舍入误差的问题，导致精度无法保证。

综上所述，计算 π 的前一亿位需要的计算量和复杂度都非常大，目前还没有已知的快速且精确的方法。如果有这样的方法，那将是一个重大的科学突破。

### 回答3：
要快速且精确地求π的前一亿位，可以使用一种名为Bailey-Borwein-Plouffe (BBP) 算法的方法。该算法是由Simon Plouffe在1995年发现的，它可以直接计算π的任意位数，而不需要依赖之前的计算结果。

BBP算法的基本思想是将π表示成一个无穷级数的形式，并使用一些数学运算来逐步计算每一位的值。下面是使用BBP算法计算π的前一亿位的代码实现：

def calculate_pi(n):
    pi = 0.0
    for k in range(n):
        numerator = 1.0 / pow(16, k)
        term1 = 4.0 / (8*k + 1)
        term2 = 2.0 / (8*k + 4)
        term3 = 1.0 / (8*k + 5)
        term4 = 1.0 / (8*k + 6)
        pi += numerator * (term1 - term2 - term3 - term4)
    
    return pi

# 计算π的前一亿位
n = 100000000
pi = calculate_pi(n)
pi_str = str(pi)

# 输出结果
print(pi_str)

这段代码首先定义了一个`calculate_pi`函数，用于计算π的近似值。函数中的循环通过迭代计算每一个分数项，并将其加到π的近似值中。最后，将近似值转换为字符串形式，并输出结果。

需要注意的是，由于π是一个无理数，其小数部分是无限不循环的，所以计算出的π值只是一个近似值。然而，由于BBP算法的特殊性，可以保证其计算结果的准确性和收敛性。

由于π的前一亿位数比较大，计算时间可能会非常长。为了加快计算速度，可以使用并行计算或其他优化技术。此外，在实际应用中，通常只需要计算到一定的精度即可满足需求。