程序在尝试 运行 时停止工作

Question

我为 拉格朗日插值 编写了一个程序，它可以编译。不幸的是，当我 运行 代码块 中的程序时，它只显示警告 "Program stopped working"。

在 Dev-C++ 中它 returns 值超过 32 000 000。

你能检查一下代码并告诉我为什么吗？你有代码：

#include <iostream>
#include<stdlib.h>
using namespace std;

struct wielo
{
    double a, b, c, d, e, f;
};

double *mnozenie(double A[], double B[], int m, int n)
{
    double *prod = new double[m + n - 1];

    for (int i = 0; i < m + n - 1; i++)
        prod[i] = 0;

    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
            prod[i + j] += A[i] * B[j];
    }

    return prod;
    delete prod;
}

int main()
{
    int wierz = 3; // max 6
    int sizeW = wierz - 1;
    double wynik = 0;
    double szukana = 5;
    double tabX[wierz];
    double tabY[wierz];
    double *tabTT;
    double wynikowy[wierz];

    tabX[0] = 1;
    tabX[1] = 2;
    tabX[2] = 4;

    tabY[0] = 3;
    tabY[1] = 4;
    tabY[2] = 6;

    wielo w[] =
    {
    { 0, 0, 0, 0, 0, 0 },
    { 0, 0, 0, 0, 0, 0 },
    { 0, 0, 0, 0, 0, 0 } };

    wynikowy[0] = 0.0;
    wynikowy[1] = 0.0;
    wynikowy[2] = 0.0;
    int k = 0;
    for (int i = 0; i < wierz; i++)
    {
        double dzialanie = 0;
        dzialanie = tabY[i];

        for (int j = 0; j < wierz; j++)
        {
            if (tabX[i] != tabX[j])
            {
                dzialanie *= (szukana - tabX[j]);
            }
        }

        for (int j = 0; j < wierz; j++)
        {
            if (tabX[i] != tabX[j])
            {
                dzialanie /= (tabX[i] - tabX[j]);
            }
            if (tabX[i] != tabX[j] && i < j)
            {
                double *tabT1;
                double *tabT2;
                tabT1[0] = 1;
                tabT1[1] = tabX[j] * (-1);
                tabT2[0] = 1;
                tabT2[1] = tabX[i] * (-1);
                tabTT = mnozenie(tabT1, tabT2, sizeW, sizeW);
                w[k].a = tabTT[0];
                w[k].b = tabTT[1];
                w[k].c = tabTT[2];
                k++;
            }
        }
        wynik += dzialanie;
        cout << dzialanie << endl;
    }
    double x, y, z;
    x = tabY[0] / ((tabX[0] - tabX[1]) * (tabX[0] - tabX[2]));
    y = tabY[1] / ((tabX[1] - tabX[0]) * (tabX[1] - tabX[2]));
    z = tabY[2] / ((tabX[2] - tabX[0]) * (tabX[2] - tabX[1]));
    for (int i = 0; i < wierz; i++)
    {
        if (i == 0)
        {
            wynikowy[0] = wynikowy[0] + (w[i].a * x);
            wynikowy[1] = wynikowy[1] + (w[i].b * x);
            wynikowy[2] = wynikowy[2] + (w[i].c * x);
        }
        if (i == 1)
        {
            wynikowy[0] = wynikowy[0] + (w[i].a * y);
            wynikowy[1] = wynikowy[1] + (w[i].b * y);
            wynikowy[2] = wynikowy[2] + (w[i].c * y);
        }
        if (i == 2)
        {
            wynikowy[0] = wynikowy[0] + (w[i].a * z);
            wynikowy[1] = wynikowy[1] + (w[i].b * z);
            wynikowy[2] = wynikowy[2] + (w[i].c * z);
        }

    }
    cout << "Wzor to: " << wynikowy[0] << "X^2 " << wynikowy[1] << "X " << wynikowy[2] << endl;
    cout << "Wynik dla x=" << szukana << " " << "y=" << wynik << endl;

    return 0;
}

Answer 1

你的主要问题在这里。

double *tabT1;
double *tabT2;
tabT1[0]=1;
tabT1[1]=tabX[j]*(-1);
tabT2[0]=1;
tabT2[1]=tabX[i]*(-1);

您还没有分配内存，相反，您刚刚声明了 double 指针 tabT1 和 tabT2 并通过假装您已经分配来访问它们。

double *tabT1 = new double[2];
double *tabT2 = new double[2];

会解决这个问题，但是，我强烈建议你改用 smart pointers，这对你来说更安全，因为看起来你有很多指针数组。

---

编辑：以上修复将导致内存泄漏，因为您不必为删除这些指针数组而烦恼，在它们使用后，每次结束 for 循环.一种可能的智能指针修复可能是：

std::unique_ptr<double[]> tabTT = nullptr;  // change
.....
.....

if(tabX[i] != tabX[j] && i<j)
{
   std::unique_ptr<double[]> tabT1 = std::unique_ptr<double[]>(new double[2]);  // change
   std::unique_ptr<double[]> tabT2 = std::unique_ptr<double[]>(new double[2]);  // change
   .....
   .....
   tabTT = mnozenie(std::move(tabT1), std::move(tabT2),sizeW,sizeW);
   .....
}

并且在函数中：

auto mnozenie(std::unique_ptr<double[]> A, std::unique_ptr<double[]> B, int m, int n)
{
   std::unique_ptr<double[]> prod = std::unique_ptr<double[]>(new double[m+n-1]);
   // calculations....    
   return std::move(prod);
}

---

附带说明：double tabX[wierz]; ISO C++ 标准中禁止声明类型（可变长度数组）。另一种方法是 std::vector<>，它也会为您动态分配一个连续的数组。