指针错误，中断删除 [] 指针 [关闭]

Question

我是 C++ 新手，在编译这段代码时遇到了问题。我正在从另一种语言中翻译它，所以我对指针的工作方式有疑问。我认为错误可以通过循环期间的指针初始化来产生。 无论如何，代码的目的是：存储变量结果并在模拟数据详细说明后将其打印出来。我的数据在每个循环中都会改变大小，所以我在循环内初始化了数组。

    using namespace std;

    int* Mwa(double price[], string data[], const int period, const int size)
    {
        double bandup;
        double banddw;
        int *index;

        index = new int[size];
        for(int i = 0; i < size; i++)
            index[i]=1;

        double cmP = size/period;
        double cmp = floor(cmP);
        double m;
        double std;

        for(int i = 0; i < period; i++)
        {
            m = 0;
            std = 0;

            for(int j = i*cmp; j < (i+1)*cmp - 1; j++)
            {
                m += price[j];
            }

            m = m/cmp;

            for(int j = i*cmp; j < (i+1)*cmp - 1; j++)
            {
                std += pow(price[j] - m,2);
            }

            std = pow(std/cmp, 0.5);

            bandup = m + NormalCDFInv(.95)*std; // aggiungere Z value in qlc modo
            banddw = m - NormalCDFInv(.95)*std; // aggiungere Z value in qlc modo

            for(int j = i*cmp; j < (i+1)*cmp - 1; j++)
            {
                if(price[j]> bandup)
                    index[j] = 0;
                else if(price[j]< banddw)
                    index[j] = 0;
                else
                    index[j] = 1;
            }
        }

        return index;
    }


    ///////////////////////////////////////////////////// MAIN /////////////////////////////////////////////////////////////////////
    void main()
    {
        const int bdays = 251;
        std::string f; 
        cout << "Insert the path of Real Dates to be used \n";
        std::cin >> f;
        if(f.size() < 5)
        f = "H:/Bid-Ask/C++/Bid-Ask Project/Bid-Ask Project/DateReali.txt";

        cout << "Insert the path of GTR Input Data to be used \n";
        std::string path;
        std::cin >> path;
        if(path.size() < 5)
        path = "H:/Bid-Ask/";

        cout << "Insert an Integer number of simulations \n";
        int sim;
        std::cin >> sim;

        double T = 1;
        int dayC = 252;
        double dt = T/dayC;

        int expiry[15] = {1,2,3,4,5,6,7,8,9,10,12,15,20,30,50};

        std::string name = " y.csv";
        int period = 15;


        const double sigmaeps = 0.051;
        const double sigmaeta = 0.091;

        double **results;
        results = new double*[sim];
        for(int i =0; i < 15; i++)
            results[i] = new double[sim];

        double *param;

        for(int rnd = 0; rnd < sim; rnd++)
        {
            for(int e = 0; e < period; e++)
            {
                stringstream ss;
                ss << expiry[e];

                string exp = ss.str();

                string line;

                std::ifstream filein;
                filein.open ((path) + exp + name);

                if(filein.fail())
                {
                    std::cout << "File opening error" << std::endl;
                }
                else
                {
                    double *cleanprice;
                    string *cleandata;
                    string *cleantime;
                    int *price2;                
                    double *series;
                    double *ret;
                    double *price;
                    string *data;
                    string *time;
                    int count = 0;
                    while(getline(filein,line))
                    {
                        count++;
                    }
                    filein.close();
                    int c = count-1; 

                    data = new string[c];
                    time = new string[c];
                    price = new double[c];

                    cout << exp + "\t" << count << "\n";

                    filein.open (path + exp + name);                    
                    for(int i = 0; i<count; i++)            
                    {           
                        int cols;
                        if(i==0)
                            cols = 49;
                        else
                            cols = 47;

                        for(int j=0; j < cols; j++)     
                        {       
                            getline(filein,line,',');   
                            if(i == 0)
                                continue;
                            if(j==2)    
                            {   
                                data[i-1] = line.substr(1,10);
                                time[i-1] = line.substr(12,8);
                                //cout << data[i-1] + "\t";
                            }   
                            else if(j == 20)    
                            {   
                                    std::istringstream stm;
                                    stm.str(line.substr(1,line.length()));
                                    stm >> price[i-1];
                                    //price[i-1] = atof((line.substr(2,line.length())).c_str());
                                //cout << price[i-1] << "\n";
                            }   
                            else    
                                continue;
                        }       
                    }   
                    filein.close();

                    price2 = Mwa(price, data, period, c); 

                    int newc = cumsumC(price2,c);

                    cleantime = new string[newc];
                    cleanprice = new double[newc];
                    cleandata = new string[newc];

                    int Ix = 0;
                    for(int i=0; i<c; i++)
                    {
                        if(price2[i] == 1)
                        {
                            cleanprice[Ix]=price[i];
                            cleantime[Ix] = time[i];
                            cleandata[Ix] = data[i];
                            Ix++;
                        }
                    }

                    //for(int i = 0; i < newc; i++)
                    //cout << cleanprice[i] << "\t" << cleandata[i] << "\t" << cleantime[i] << "\n";

                    ret = SimpleReturns(cleanprice, cleandata, cleantime, newc);

                     std::ofstream file;
                        file.open( f + "/Ret.txt",std::ios::out ) ; 

                        for(int i = 0; i < newc; i++)
                            file << ret[i] << "\t" << cleanprice[i] << "\t" << cleandata[i] << std::endl;

                        file.close();

                    series = KalmanFiltering(f, sigmaeps, sigmaeta, ret, cleandata, newc);

                     std::ofstream file1;
                        file1.open(f + "/Kalman.txt",std::ios::out) ; 

                        for(int i = 0; i < bdays; i++)
                            file1 << series[i] << "\n";

                        file1.close();

                    param = MA1(series, bdays);

                    double bps = pow(abs(param[0]),.5)*param[1]*100;

                    cout << param[0] << "\t" << param[1] << "\t" << bps << "\r\n";

                    results[e][rnd] = bps;

                    delete[] cleantime;
                    delete[] cleanprice;
                    delete[] cleandata;
                    delete[] time;          
                    delete[] data;  
                    delete[] price;
                    delete[] price2;
                    delete[] series;
                    delete[] ret;

                }// Else in file reading

            }// loop over expiries

        }// loop over simulation

        std::ofstream fileR;
        fileR.open( path + "Results.txt", std::ios::out); 

        if(fileR.fail())
            {
                std::cout << "File opening error" << std::endl;
            }
        else
        {
            fileR << "Expiry" << endl;
            for(int e = 0; e < 15; e++)
            {   
                stringstream ss;
                ss << expiry[e];
                string exp = ss.str();

                fileR << exp << " y" << "\t";

                for(int rnd = 0; rnd < sim; rnd++)
                {
                    fileR << results[e][rnd] << "\t";
                }
                fileR << endl;
            }
        }

        fileR.close();


        for(int i =0; i < 15; i++)
            delete[] results[i];
        delete[] param;
    }


double* MA1(double ret[], const int sizeEr)
{   
    double *Param = new double[1];

    int gran = 100;
    double* grid;
    double* gridV;
    grid = new double[gran]; grid[0] = -1;
    gridV = new double[gran]; gridV[0] = 0;

    for(int i = 1; i < gran; i++)
    {
        grid[i] = grid[i-1]+.02;
        gridV[i] = gridV[i-1]+ .005;
        //cout << grid[i] << "\n";
    }

    double **F;
    F = new double*[gran];
    for(int i = 0; i < gran; i++)
        F[i]= new double[gran];

    for(int a = 0; a < gran; a++)
    {   
        double GhostTerm = 0.0;

        for(int i = 2; i< sizeEr; i++)
            {   
                double c = 0;

                for(int g = 0; g < i-1; g++)
                    c += pow((-grid[a]),g)*(ret[i-g]);

                GhostTerm += pow(c,2);
            }

        for(int v = 0; v < gran; v++)
        {
            F[a][v] = -(sizeEr-1)*.5 *log(2*3.14159*pow(grid[v],2)) + (-.5)*GhostTerm/pow(grid[v],2);

        }// loop on vola
    }// loop on beta

    double m = -gran;
    int posB = 1;
    int posV = 1;

    for(int i = 1; i < gran; i++)
    {   for(int j = 1; j < gran; j++)
        {
            if(abs(grid[i]) < .01)
                continue;
            else
            {
                m = max(F[i][j],m);
                if(F[i][j] == m)
                { 
                    posB = i;
                    posV = j;
                }
            }
        }
    }

    Param[0] = grid[posB];
    Param[1] = gridV[posV];

    delete[] F;
    delete[] grid;
    return Param;
}

#endif __MA1_H_INCLUDED__


#ifndef __KALMANFILTERING_H_INCLUDED__
#define __KALMANFILTERING_H_INCLUDED__

#include <iostream> 
#include <fstream>
#include <string>
#include <sstream>  
#include <stdio.h> 
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "MyLib.h"
#include <array>


using namespace std;

double* KalmanFiltering(std::string path, const double sigmaeps, const double sigmaeta, double ret[], string data[], int size)
{
    //srand (time(NULL));
    string *Realdata;
    double *Sim;
    std::ifstream filein;
    filein.open (path);
    int count = 0;
    double *a;
    double *P;

    if(filein.fail())
        {
            std::cout << "File opening error" << std::endl;
            return 0;
        }
    else
        {
            string line;
            while(getline(filein,line))
                {
                    count++;
                }
            filein.close(); 

            Sim = new double[count];
            Realdata = new string[count];

            filein.open(path);
            for(int i = 0; i<count; i++)            
                {               
                        getline(filein,line);   
                        Realdata[i] = line;
                        //cout << Realdata[i];
                }   
            }

            filein.close();

            a = new double[count];
            P = new double[count];

            a[0]= mean(ret, size);
            P[0]= variance(ret, size);

            int *idx;
            idx = new int[size];
            for(int i=0; i < count;i++)
            {   
                const char *chrR = Realdata[i].c_str();
                double GhostR= 0.0;
                for(int j=0; j < size; j++)
                {   
                    const char *chrD = data[j].c_str();
                    if(strcmp(chrR, chrD)== 0)
                    {
                        idx[j] = 1.0;
                        GhostR += ret[j];
                    }
                    else
                        idx[j] = 0.0;
                }

                if(cumsumC(idx,size) != 0)
                {   
                    double v = GhostR/cumsumC(idx,size) - a[i];
                    double F = P[i] + sigmaeps*sigmaeps;
                    a[i+1] = a[i]+(P[i]/F)*v;
                    P[i+1] = P[i]*(1- P[i]/F) + sigmaeta*sigmaeta;
                }
                else
                {
                    a[i+1]= a[i];
                    P[i+1]= P[i] + sigmaeta*sigmaeta;
                }

            }// Loop over real data

            for(int i=0; i < count;i++)
            {   
                double GhostR = 0;
                int counter = 0;
                const char *chrR = Realdata[i].c_str();

                for(int j=0; j < size; j++)
                {
                    if(strcmp(chrR,data[j].c_str())== 0)
                    {
                        idx[j] = 1.0;
                        counter++;
                        GhostR += ret[j];
                    }
                    else
                        idx[j] = 0;
                }

                if(cumsumC(idx,size) != 0)
                {   
                    Sim[i] = GhostR/counter;
                }
                else
                {
                    double s = rand() % 9999 + 1;
                    Sim[i] = a[i] + pow(P[i],2)*NormalCDFInv(s/10000);
                }

            }// Loop over Simulation

            delete[] idx;
            //delete[] a;
            //delete[] P;
            delete[] Realdata;

            return Sim;
}// Kalman End

#endif _KALMANFILTERING_H_INCLUDED_

Answer 1

您不需要为此使用数组。 C++ 有一个很好的 std::vector 类，它不需要删除或手动内存管理，请使用它：

http://www.cplusplus.com/reference/vector/vector/

double *price;
string *data;

data = new string[c];
price = new double[c];

可以写成：

std::vector<double> price;
std::vector<std::string> data;

data.reserve(c);
price.reserve(c);

而且您不必担心有趣的内存块的分配/释放。