Question

我已经研究过这个错误，这似乎与危险的内存分配或过载相关，但我无法找到适用于我的代码的地方。基本上我一直收到错误信息：

分段错误：11

每次在参数化的Fraction构造函数定义中调用简化函数后运行我的代码。这很有趣，因为当我在这个定义中调用更改函数时，它完全被忽略了。我试图找出如何让更改至少工作，这样我就可以弄清楚如何正确应用简化，但我一直在这个年龄很长，我仍然不知所措。

我有三个文件：fraction.h，fraction.cpp和main.cpp。 Main.cpp是由我的教授编写的 - 这是一个用于创建头文件和实现文件的任务，以允许他的代码运行。这个特定部分的说明是：

名为简化的私有成员函数，可将分数减少到它的最低期限（12/15 => 4/5）。如果编写函数，则应在参数化构造函数定义中调用简化函数，以便以简化形式创建函数。

// fraction.h：

#ifndef FRACTION_
#define FRACTION_

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

using namespace std;

class Fraction {

private:
    int numerator;
    int denominator;
    int change (int a, int b);
    Fraction simplify (int n, int d);

public:

    Fraction();

    Fraction (int num, int denom);

    Fraction sumWith (Fraction a);

    Fraction multiplyWith (Fraction z);

    void const print (ostream & out) const;

};

#endif /* defined(____Fraction__) */

// fraction.cpp [不受影响的函数除外]：

#include "fraction.h"
#include <iostream>
#include <math.h>

using namespace std;

int Fraction::change(int a, int b){
    int temp;
    temp = a;
    a = b;
    b = temp;
    return temp; }

Fraction Fraction::simplify (int n, int d){
    int r, gcd, true_n, true_d, q;

    true_n = n;
    true_d = d;

    if ((n) < (d)){
        change (n, d);
        q = 5; }

    r = (n % d);

    if ((r != 1) && (r != 0)){
        for (int i = 0; r > 1; i++){
            r = (n % d);
            d = n;
            r = d;
            i++; }

        if (r == 0){
            gcd = n;
            n = true_n/gcd;
            d = true_d/gcd; }

        else {
            n = true_n;
            d = true_d; }
    }

    if (r == 0){
        n = n/d;
        d = 1; }

    if (q == 5){
        change (n, d); }

    return Fraction(n, d); }

Fraction::Fraction() {
    numerator = 1;
    denominator = 1; }


Fraction::Fraction (int num, int denom) {

        if (denom == 0) {
            cerr << "Denominator may not be 0.";
            exit (EXIT_FAILURE); }
        else {
            numerator = num;
            denominator = denom; }

        if (denominator < 0){
            denominator = denominator * -1;
            numerator = numerator * -1; }

    simplify (numerator, denominator);
}

//适用的main.cpp摘录：

void outputExpression(ostream & out,
                      const Fraction & num1,
                      const Fraction & num2,
                      const Fraction & result,
                      bool isSum);

int main() {
    Fraction num1, num2, result;

    num1 = Fraction(1, 2);
    num2 = Fraction(2, 3);
    result = num1.sumWith(num2);
    outputExpression(cout, num1, num2, result, true);
    result = num1.multiplyWith(num2);
    outputExpression(cout, num1, num2, result, false);
    cout << endl;

Answer 1

我完全阅读了您的代码，并找出了编写此代码的方案，您的代码中存在严重问题： 1-功能变化的定义必须采用以下格式：

int Fraction::change(int* a, int* b){
int temp;
temp = *a;
*a = *b;
*b = temp;
return *temp; }

2-在你的构造函数中你调用简化函数，

simplify (numerator, denominator);

同样在你的简化函数中，你调用了分数构造函数：

simplify (numerator, denominator);

这是一个无限循环，会导致堆空间过多（使用堆的合法数量的一个程序）。

3 - 在简化功能中，你写：

if ((r != 1) && (r != 0)){
    for (int i = 0; r > 1; i++){
        r = (n % d);
        d = n;
        r = d;
        i++; }

这是一个问题，因为你必须在d = n之前将d保存在临时变量中;

否则下一个命令（r = d;）将等效于r = n;

您必须解决此逻辑错误才能解决碎片错误。在这种情况下导致此错误：

当程序使用大于其合法的堆使用量的堆的大空间时。在某些情况下，生成对象或获取内存（alloc | malloc）属于无限循环。

Answer 2

在你的构造函数中，你有：

Fraction::Fraction (int num, int denom) {
    // ...
    simplify (numerator, denominator);
}

然后，在simplify中你有：

Fraction Fraction::simplify (int n, int d){
    // ...
    return Fraction(n, d);
}

这是一个无限循环。

您可以通过以下两种方式之一修复它：

如果您不想允许未经简化的分数，请使simplify修改对象而不是返回新对象。

像这样：

numerator = n;
denominator = d;

您当前的simplify基本上是一种构建器方法。您传递了n和d，并为您返回简化的Fraction。这些方法应该是static。您不应该在构造函数中调用simplify，而是将其声明为static并使用它，如下所示：num1 = Fraction::simplify(1, 2);

在构造函数定义中调用函数后接收分段错误11错误？

2 个答案: