Форум программистов [Powered by Invision Power Board]

Версия для печати темы
Нажмите сюда для просмотра этой темы в оригинальном формате

Форум программистов > C/C++: Общие вопросы > Debug Assertion Filed

Автор: Karen_ 27.5.2008, 19:54

может быть есть темы этого типа, но если не трудно не удалите и если кто может помогите smile

есть у меня класс, в котором у меня обявлен массив:

Код


class test
{
public int **A;
}

в классе есть функции которые инициализируют эту матрицу:
потом в main-е с помощью обйекта получаю матрицу, скажем так:

Код


# include <iostream>
char B[100][100];
int main()
{
test obj;

}

потом копирую в B матрицу A таким образом

Код



while(condition)
{
if(obj.A[i][j]>0)
{
B[i][j]='1';
}
else B[i][j]='0';
somefunction();
}

этот somefunction  в B  скажем находит число нулевих элементов, потом редактирует матрицу A, то есть вычитвыает из всех эелемнтов минимальный эелемнт, и так до тех пор пока не находит скажем N нулей:
если размер матрицы A меньше 10, то вроди бы все делается нормально но если размер больше 10, во время работы выдает ошибку:
Debug Assertion Filed
File Dbgheap.cpp
line 346
Expression CrtCheckMemory()

есть кноки Abort Retry  Ignore
если нажать на Ignore То прога  почти всегда доходит до конца и выдает результаты:
потом ошибку, бывает и так что без ошибки завершает работу:
как исправить прогу?

Автор: Rififi 27.5.2008, 20:01

Цитата(Karen_ @ 27.5.2008, 19:54

)

как исправить прогу?

поскольку код у тебя секретный, то сказать что-то конкретное сложно... переписать кривизну по-нормальному?

Автор: bsa 27.5.2008, 20:16

Karen_
Это сообщение скорее всего значит, что ты вышел за границы массива (т.е. обратился к 11-му элементу массива, в котором всего их 10).

Автор: Karen_ 27.5.2008, 20:17

код не секретный просто он очень большой, почти 1000 строк:
вот тот отрезок где копирую матрицу в другую, и отыскиваються те места где пересикаються множества в которых есть все нулевые элементы(просто не хотел писать все это чтобы не усложнить вопрос)

Код



#include <iostream>
using namespace std;

int n,m;
int counter,hold_c,min_c=10000000;
int min_h=1000000;
char a[1000][1000];
char hold_a[1000][1000];
char min_a[1000][1000];
void save_a(void)
{
    int i,j;
    for(i=0;i<n;i++)
        for(j=0;j<m;j++)
            hold_a[i][j]=a[i][j];
    hold_c=counter;
}

void restore_a(void)
{
    int i,j;
    for(i=0;i<n;i++)
        for(j=0;j<m;j++)
            a[i][j]=hold_a[i][j];
    counter=hold_c;
}

int ret_hatumner()
{
    int i,j,s=0;
    for(i=0;i<n;i++)
        for(j=0;j<m;j++)
            if(a[i][j]=='+')
                s++;
    return s;
}

void fill_row(int i,int j)
{
    int k;
    for(k=j;a[i][k]!='1' && k>=0;k--);
    for(k++;a[i][k]!='1' && k<m;k++)
        if(a[i][k]=='|')
            a[i][k]='+';
        else
            a[i][k]='-';
    counter++;
}

void fill_coloumn(int i,int j)
{
    int k;
    for(k=i;a[k][j]!='1' && k>=0;k--);
    for(k++;a[k][j]!='1' && k<n;k++)
        if(a[k][j]=='-')
            a[k][j]='+';
        else
            a[k][j]='|';
    counter++;
}

void backtrack(void)
{
    if(counter>min_c)
        return;
    int i,j;
    save_a();
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
            if(a[i][j]=='0')
                break;
        if(j!=m)
            break;
    }
    if(i==n && j==m)
    {
        if(min_c>counter || (min_c==counter && min_h>ret_hatumner()))
        {
            min_c=counter;
            min_h=ret_hatumner();
            for(i=0;i<n;i++)
                for(j=0;j<m;j++)
                    min_a[i][j]=a[i][j];
        }
        return;
    }
    fill_row(i,j);
    backtrack();
    restore_a();
    fill_coloumn(i,j);
    backtrack();
    restore_a();
}

void solve(void)
{
    int i,j;
    counter=0;
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            if(a[i][j]=='0')
            {
                if((i==n-1 || a[i+1][j]=='1') && (i==0 || a[i-1][j]=='1'))
                {
                    fill_row(i,j);
                }
                else if((j==m-1 || a[i][j+1]=='1') && (j==0 || a[i][j-1]=='1'))
                {
                    fill_coloumn(i,j);
                }
            }
            backtrack();
        }
    }
    return;
}
int main()
{
test obj;
n=obj.count;//здесь размер матрицы;
while(nc<n)
        {
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    if(obj.A[i][j]>0)
                    {
                        a[i][j]='1';
                    }
                    else a[i][j]='0';
                }
            }
            solve();
            hf=obj.hfind();//возвращает минимальный элемент
            for(int i=0;i<n;i++)
                for(int    j=0;j<n;j++)
                {
                    if(min_a[i][j]=='+')
                    {
                        obj.A[i][j]-=hf;
                    }
                    else if(obj.A[i][j]>0)
                    {
                        obj.A[i][j]-=hf;
                    }
                }

            nc=obj.nullcount();//
        }
}

Автор: Rififi 27.5.2008, 21:28

- не показана самая интересная часть - создание и уничтожение массива указателей A
- начни уже потихоньку юзать STL. например эта телега:

Код

int ret_hatumner()
{
    int i,j,s=0;
    for(i=0;i<n;i++)
        for(j=0;j<m;j++)
            if(a[i][j]=='+')
                s++;
    return s;
}

(кстати, почему возвращается int? или число плюсов может быть отрицательным?)

записывается так:

Код

size_t ret_hatumner()
{
    return std::count(&a[0][0], &a[0][0]+n*m, '+');
}

а учитывая, что размерности массивов у тебя - константы, большинство проверок можно делать в compile-time, причём без использования глобальных переменных вообще (которые - зло, и юзаются только ламерами).

Код

template <typename T, const size_t Cols, const size_t Rows)
size_t ret_hatumner(const T (&arr)[Cols][Rows])
{
    return std::count(&arr[0][0], &arr[0][0]+Cols*Rows, '+');
}

- стоит подумать о том, чтобы хоть как-то ловить выход за пределы массива (сейчас никакого контроля нет вообще)
хотя бы так:

Код

int& Obj::operator()(size_t i, size_t j)
{
    if (i > ... || j > ... ) throw ...
    return A[i][j];
}

Obj obj;
obj(100, 100) = 0;

или дополнительный класс(ы), чтобы сохранить текущий синтаксис.

в общем, работать есть над чем.

Добавлено через 1 минуту и 53 секунды
и эта. не стесняйся пользоваться пробелом в коде, не экономь байты.

Автор: Karen_ 27.5.2008, 21:52

вот так создаю матрицу A

Код


test::test(int n)
{
tmp2=n;
A=new int*[tmp2];
for(int i=0;i<tmp2;i++)
A[i]=new int[tmp2];
for(int i=0;i<tmp2;i++)
{
    for(int j=0;j<tmp2;j++)
    {
        A[i][j]=0;
    }
}
}

а так в деструкторе удаляю

Код


test::~test()
{
for(int i=0;i<tmp2;i++)
delete A[i];
delete []A;
}

Автор: Rififi 27.5.2008, 22:07

код выглядит корректным. если сообщение появляется во время работы, значит память портится на какой-то итерации.
начни добавлять трассировку (printf/file io) (чем дальше - тем больше) и дампить на экран/файл все важные значения.
продолжать до тех пор, пока результаты трассировки не разойдутся с ожидаемыми, после чего локализовать ошибку и исправить её.

Автор: Karen_ 27.5.2008, 22:15

огромное спасибо, постараюсь.
и еще, в разных компиляторах ошибка выдает по разному.
например в Visual Studo 7, во время работы постоянно выдает ошибку, который я уже написал, в Visual Studio 2005, почти всегда программа работает до конца выдает результаты, а потом уже ошиби:
в GCC(под Linux) вроди бы работает нормально , пишет результаты, после нажатия Enter пишет Segmentation fault, Core dumped

Автор: bsa 27.5.2008, 22:36

Код

for(int i=0;i<tmp2;i++)
   delete A[i];

Это неверно. Должно быть delete []A[i];