c++ - C++ 类函数未处理的异常

Question

我正在编写一个程序来执行纹理合成。我已经离开 C++ 一段时间了，我很难弄清楚我在类里面做错了什么。当我运行程序时，copyToSample 函数尝试访问数组时出现未处理的异常。当未处理的异常发生时，从 bestSampleSearch 函数调用它。该函数之前已被调用并且工作正常，但稍后在程序中第二次调用它并失败。有任何想法吗？让我知道是否有人需要查看更多代码。谢谢!

Edit1:添加了bestSampleSearch函数和compareMetaPic函数
Edit2:添加了一个复制构造函数
Edit3:添加了 main()
Edit4:我已经让程序开始工作了。但是现在存在某种内存泄漏，或者我在运行程序时内存不足。似乎在 main 中的双 for 循环中开始“//while output picture is unfilled”是问题所在。如果我将这部分注释掉，程序会及时完成，但只输出一个小方 block 。我的 bestSampleSearch 函数一定有问题。

元图片.h

#pragma once
#include <pic.h>
#include <stdlib.h>
#include <cmath>

class MetaPic
{
    public:
        Pic* source;
        Pixel1*** meta;
        int x;
        int y;
        int z;
        MetaPic();
        MetaPic(Pic*);
        MetaPic(const MetaPic&);
        MetaPic& operator=(const MetaPic&);
        ~MetaPic();
        void allocateMetaPic();
        void copyPixelData();
        void copyToOutput(Pic*&);
        void copyToMetaOutput(MetaPic&, int, int);
        void copyToSample(MetaPic&, int, int);
        void freeMetaPic();

};

元图片.cpp

#include "MetaPic.h"

MetaPic::MetaPic()
{
    source = NULL;
    meta = NULL;
    x = 0;
    y = 0;
    z = 0;
}

MetaPic::MetaPic(Pic* pic)
{
    source = pic;
    x = pic->nx;
    y = pic->ny;
    z = pic->bpp;
    allocateMetaPic();
    copyPixelData();
}

MetaPic::MetaPic(const MetaPic& mp)
{
    source = mp.source;
    x = mp.x;
    y = mp.y;
    z = mp.z;
    allocateMetaPic();
    copyPixelData();
}

MetaPic::~MetaPic()
{
    freeMetaPic();
}

// create a 3 dimensional array from the original one dimensional array
void MetaPic::allocateMetaPic()
{
    meta = (Pixel1***)calloc(x, sizeof(Pixel1**));

    for(int i = 0; i < x; i++)
    {
        meta[i] = (Pixel1**)calloc(y, sizeof(Pixel1*));
        for(int j = 0; j < y; j++)
        {
            meta[i][j] = (Pixel1*)calloc(z, sizeof(Pixel1));
        }
    }
}

void MetaPic::copyPixelData()
{
    for(int j = 0; j < y; j++)
    {
        for(int i = 0; i < x; i++)
        {
            for(int k = 0; k < z; k++)
                meta[i][j][k] = source->pix[(j*z*x)+(i*z)+k];
        }
    }
}

void MetaPic::copyToOutput(Pic* &output)
{
    for(int j = 0; j < y; j++)
    {
        for(int i = 0; i < x; i++)
        {
            for(int k = 0; k < z; k++)
                output->pix[(j*z*x)+(i*z)+k] = meta[i][j][k];
        }
    }
}

// copy the meta data to the final  pic output starting at the top left of the picture     and mapped to 'a' and 'b' coordinates in the output
void MetaPic::copyToMetaOutput(MetaPic &output, int a, int b)
{
    for(int j = 0; (j < y) && ((j+b) < output.y); j++)
    {
        for(int i = 0; (i < x) && ((i+a) < output.x); i++)
        {
            for(int k = 0; k < z; k++)
                output.meta[i+a][j+b][k] = meta[i][j][k];
        }
    }
}

// copies from a source image to a smaller sample image
// *** Must make sure that the x and y coordinates have enough buffer space ***
void MetaPic::copyToSample(MetaPic &sample, int a, int b)
{
    for(int j = 0; (j < sample.y) && ((b+j) < y); j++)
    {
        for(int i = 0; i < (sample.x) && ((a+i) < x); i++)
        {
            for(int k = 0; k < sample.z; k++)
            {
                    **sample.meta[i][j][k] = meta[i+a][j+b][k];**
            }
        }
    }
}

// free the meta pic data (MetaPic.meta)
// *** Not to be used outside of class declaration ***
void MetaPic::freeMetaPic()
{
    for(int j = 0; j < y; j++)
    {
        for(int i = 0; i < z; i++)
            free(meta[i][j]);
    }
    for(int i = 0; i < x; i++)
        free(meta[i]);

    free(meta);
}

MetaPic MetaPic::operator=(MetaPic mp)
{
    MetaPic newMP(mp.source);

    return newMP;
}

主要.cpp

#ifdef WIN32
// For VC++ you need to include this file as glut.h and gl.h refer to it
#include <windows.h>
// disable the warning for the use of strdup and friends
#pragma warning(disable:4996) 
#endif
#include <stdio.h>     // Standard Header For Most Programs
#include <stdlib.h>    // Additional standard Functions (exit() for example)
#include <iostream>
// Interface to libpicio, provides functions to load/save jpeg files
#include <pic.h>
#include <string.h>
#include <time.h>
#include <cmath>

#include "MetaPic.h"

using namespace std;

MetaPic bestSampleSearch(MetaPic, MetaPic);
double compareMetaPics(MetaPic, MetaPic);

#define SAMPLE_SIZE 23
#define OVERLAP 9

// Texture source image (pic.h uses the Pic* data structure)
Pic *sourceImage;
Pic *outputImage;
int main(int argc, char* argv[])
{
    char* pictureName = "reg1.jpg";
    int outputWidth = 0;
    int outputHeight = 0;

    // attempt to read in the file name
    sourceImage = pic_read(pictureName, NULL);
    if(sourceImage == NULL)
    {
        cout << "Couldn't read the file" << endl;
        system("pause");
        exit(EXIT_FAILURE);
    }

    // *** For now set the output image to 3 times the original height and width ***
    outputWidth = sourceImage->nx*3;
    outputHeight = sourceImage->ny*3;

    // allocate the output image
    outputImage = pic_alloc(outputWidth, outputHeight, sourceImage->bpp, NULL);
    Pic* currentImage = pic_alloc(SAMPLE_SIZE, SAMPLE_SIZE, sourceImage->bpp, NULL);

    MetaPic metaSource(sourceImage);
    MetaPic metaOutput(outputImage);
    MetaPic metaCurrent(currentImage);

    // seed the output image    
    int x = 0;
    int y = 0;
    int xupperbound = metaSource.x - SAMPLE_SIZE;
    int yupperbound = metaSource.y - SAMPLE_SIZE;
    int xlowerbound = 0;
    int ylowerbound = 0;

    // find random coordinates
    srand(time(NULL));
    while((x >= xupperbound) || (x <= xlowerbound))
        x = rand() % metaSource.x;
    while((y >= yupperbound) || (y <= ylowerbound))
        y = rand() % metaSource.y;

    // copy a random sample from the source to the metasample
    metaSource.copyToSample(metaCurrent, x, y);
    // copy the seed to the metaoutput
    metaCurrent.copyToMetaOutput(metaOutput, 0, 0);


    int currentOutputX = 0;
    int currentOutputY = 0;

    // while the output picture is unfilled...
    for(int j = 0; j < yupperbound; j+=(SAMPLE_SIZE-OVERLAP))
    {
        for(int i = 0; i < xupperbound; i+=(SAMPLE_SIZE-OVERLAP))
        {
            // move the sample to correct overlap
            metaSource.copyToSample(metaCurrent, i, j);
            // find the best match for the sample
            metaCurrent = bestSampleSearch(metaSource, metaCurrent);
            // write the best match to the metaoutput
            metaCurrent.copyToMetaOutput(metaOutput, i, j);
            // update the values
        }
    }


    // copy the metaOutput to the output
    metaOutput.copyToOutput(outputImage);

    // output the image
    pic_write("reg1_output.jpg", outputImage, PIC_JPEG_FILE);


    // clean up
    pic_free(sourceImage);
    pic_free(outputImage);
    pic_free(currentImage);

    // return success
    cout << "Done!" << endl;
    system("pause");
    // return success
    return 0;
}

// finds the best sample to insert into the image
// *** best must be the sample which consists of the overlap ***
MetaPic bestSampleSearch(MetaPic source, MetaPic best)
{
    MetaPic metaSample(best);

    double bestScore = 999999.0;
    double currentScore = 0.0;

    for(int j = 0; j < source.y; j++)
    {
        for(int i = 0; i < source.x; i++)
        {
            // copy the image starting at the top left of the source image
            source.copyToSample(metaSample, i, j);
            // compare the sample with the overlap
            currentScore = compareMetaPics(best, metaSample);
            // if best score is greater than current score then copy the         better sample to best and continue searching
            if( bestScore > currentScore)
            {
                metaSample.copyToSample(best, 0, 0);
                bestScore = currentScore;
            }
            // otherwise, the score is less than current score then do nothing     (a better sample has not been found)

        }
    }

    return best;
}

// find the comparison score for the two MetaPics based on their rgb values
// *** Both of the meta pics should be the same size ***
double compareMetaPics(MetaPic pic1, MetaPic pic2)
{
    float r1 = 0.0;
    float g1 = 0.0;
    float b1 = 0.0;
    float r2 = 0.0;
    float g2 = 0.0;
    float b2 = 0.0;
    float r = 0.0;
    float g = 0.0;
    float b = 0.0;

    float sum = 0.0;

    // take the sum of the (sqrt((r1-r2)^2 + ((g1-g2)^2 + ((b1-b2)^2))
    for(int j = 0; (j < pic1.y) && (j < pic2.y); j++)
    {
        for(int i = 0; (i < pic1.x) && (i < pic2.x); i++)
        {
            r1 = PIC_PIXEL(pic1.source, i, j, 0);
            r2 = PIC_PIXEL(pic2.source, i, j, 0);
            g1 = PIC_PIXEL(pic1.source, i, j, 1);
            g2 = PIC_PIXEL(pic2.source, i, j, 1);
            b1 = PIC_PIXEL(pic1.source, i, j, 2);
            b2 = PIC_PIXEL(pic2.source, i, j, 2);

            r = r1 - r2;
            g = g1 - g2;
            b = b1 - b2;

            sum += sqrt((r*r) + (g*g) + (b*b));
        }
    }

    return sum;
}

Answer 1

我不确定这是否是问题的根本原因，但您的赋值运算符实际上并未分配任何内容:

MetaPic MetaPic::operator=(MetaPic mp)
{
    MetaPic newMP(mp.source);

    return newMP;
}

这可能看起来像下面这样(基于复制构造函数中的代码):

编辑: 感谢 Alf P. Steinbach

MetaPic& MetaPic::operator=(MetaPic mp)
{
    mp.swap(*this);
    return *this;
}