Qt программа завершилась с ошибкой

Привет всем!
Интересно, что это за байда ?
Кодим. С ошибкой. Естественно получаем «qt программа неожиданно завершилась «
Удаляем ошибку — qt программа неожиданно завершилась
Коментим всё, фактически возвращаясь к пустому проекту, по дефолту — qt программа неожиданно завершилась
Пересборка всего — qt программа неожиданно завершилась

Режим debug без ошибки в коде — ок.
Режим release без ошибки в коде — qt программа неожиданно завершилась

Новый проект, переносим в него код без ошибки — ок
2.-й запуск без иземенений — ок
3. делаем умышленно ошибку — qt программа неожиданно завершилась
4. удаляем ошибку — qt программа неожиданно завершилась
5.Пересобираем -qt программа неожиданно завершилась

Удаляем папки debug/release , пересобираем — ок
Делаем ошибки — qt программа неожиданно завершилась , это норм
Удалаяем ошибки.
Удаляемм папки debug/releaase, пересобираем — ок.

Т.е. если я даже исправил все ошибки, и пересобрал — qt программа неожиданно завершилась
Если я перед пересборкой удалил папки debug/release — ок

Что это может быть ?

Создавал игру, вышла ошибка. Код ошибки :
The program has unexpectedly finished.
The process was ended forcefully.
build-SpaceRangers-Desktop_Qt_5_15_1_MSVC2015_64bit-DebugdebugSpaceRangers.exe crashed.

Код игры :

View.h

#pragma once

#include <QGraphicsView>
#include <QGraphicsScene>
#include <QObject>

#include "player.h"
#include "virus.h"
#include "laserbullet.h"

class View :public QGraphicsView
{
public:
    View();
    void view_elements();
    QList<QGraphicsItem*> Viruses;
    void viruspodMoving(QGraphicsItem *virus);
    void deleteVirus(QGraphicsItem *virus);

public slots:
    void addVirus();
    void virusMov();
    void PlayerAttack();

private:
    QGraphicsScene mainScene;
    Player pl;
    Virus vir;
    LaserBullet lb;
    View *v;
    QTimer     *timer; // Таймер
    QTimer *createVirus;
    QTimer *vm;
    Virus *vc;
};

View.cpp

#include "view.h"
#include "player.h"

#include <QObject>
#include <QTimer>
#include <QtGlobal>

View::View()
{

    setWindowTitle("Space Rangers");

    setRenderHint(QPainter::Antialiasing);

    setFrameStyle(0);
    setSceneRect(0, 0, 600,700);
    setFixedSize(600, 700);


    mainScene.setItemIndexMethod(QGraphicsScene::NoIndex);
    setScene(&mainScene);

    connect(&pl, &Player::IS_IT_Attack, this, &View::PlayerAttack);

    timer = new QTimer(this);
    connect(timer, &QTimer::timeout, &pl, &Player::actions);
    timer->start(1000 / 50);
    view_elements();

    vm = new QTimer(this);
    connect(vm, &QTimer::timeout, this, &View::virusMov);

    createVirus = new QTimer(this);
    connect(createVirus, &QTimer::timeout, this, &View::addVirus);
    createVirus->start(30000);

}

void View::view_elements(){

    pl.setPos(205, 400);
    mainScene.addItem(&pl);
}

void View::addVirus(){

    Virus *virus = new Virus();
    vc = virus;
    mainScene.addItem(virus);
    virus->x = ((int)rand()/(420));
    virus->setPos(vir.x, 0);
    Viruses.append(virus);
    viruspodMoving(virus);

}

void View::deleteVirus(QGraphicsItem *virus){

    foreach(QGraphicsItem *v, Viruses){
        if(v == virus){
            mainScene.removeItem(v);
            Viruses.removeOne(v);
            delete vc;
            vir.y = 0;
        }
    }

    createVirus->start(30000);
}

void View::viruspodMoving(QGraphicsItem *virus){

    if(vir.y < 671){
        emit vm->start(100);
    }

    if(vir.y >= 670){
        deleteVirus(virus);
    }

}

void View::virusMov(){

    if(vir.y < 671){
        vir.y = vir.y + 4;
        vc->setPos(vir.x, vir.y);
        viruspodMoving(vc);
       
  }

}

void View::PlayerAttack(){

    LaserBullet *bullet = new LaserBullet();
    LaserBullet *bullet2 = new LaserBullet();
    lb.x = pl.x + 41;
    lb.y = pl.y - 32;
    lb.x2 = pl.x + 25;
    lb.y2 = pl.y - 32;
    bullet->setPos(lb.x, lb.y);
    mainScene.addItem(bullet);
    bullet2->setPos(lb.x2, lb.y2);
    mainScene.addItem(bullet2);
}

Virus.h

#pragma once

#include <QtWidgets>
#include <QGraphicsItem>

class Virus: public QObject, public QGraphicsItem
{
    Q_OBJECT

public:
    Virus(QObject *parent = 0);
    ~Virus();
    int vWidth = 70;
    int vHeigth = 55;
    int x = 0;
    int y = 0;


signals:
    void checkVirus(QGraphicsItem *item);


private:
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget) override;
    QRectF boundingRect() const override;
    QPixmap *VirusImage;

};

Virus.cpp

+
#include "virus.h"
#include "view.h"

Virus::Virus(QObject *parent):QObject(parent), QGraphicsItem()
{
    VirusImage = new QPixmap();
    VirusImage->load(":/Virus.png");
}

Virus::~Virus(){

}

QRectF Virus::boundingRect() const{

    return QRectF(0, 0, vWidth, vHeigth);
}

void Virus::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget){

    painter->drawPixmap(0, 0, vWidth, vHeigth, *VirusImage);
    Q_UNUSED(option);
    Q_UNUSED(widget);

}

Здесь нам нужно использовать системный API

#include <DbgHelp.h>

Как использовать:

Добавьте следующие файлы во внешнюю программу

dbgcrash.h

#ifndef DBGCRASH_H
#define DBGCRASH_H

#include <Windows.h>
#include <DbgHelp.h>
#include <iostream>
#include <vector>
 // информация о сбое
//
using namespace std;
const int MAX_ADDRESS_LENGTH = 32;
const int MAX_NAME_LENGTH = 1024;

struct CrashInfo
{
    CHAR ErrorCode[MAX_ADDRESS_LENGTH];
    CHAR Address[MAX_ADDRESS_LENGTH];
    CHAR Flags[MAX_ADDRESS_LENGTH];
};

 // Информация CallStack
//
struct CallStackInfo
{
    CHAR ModuleName[MAX_NAME_LENGTH];
    CHAR MethodName[MAX_NAME_LENGTH];
    CHAR FileName[MAX_NAME_LENGTH];
    CHAR LineNumber[MAX_NAME_LENGTH];
};

void SafeStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc);
CrashInfo GetCrashInfo(const EXCEPTION_RECORD *pRecord);
vector<CallStackInfo> GetCallStack(const CONTEXT *pContext);
LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException);
void printStack( void );

#endif // DBGCRASH_H

файл dbgcrash.cpp

#include "dbgcrash.h"

 // Функция безопасного копирования строки
//
void SafeStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc)
{
    if (nMaxDestSize <= 0) return;
    if (strlen(szSrc) < nMaxDestSize)
    {
        strcpy_s(szDest, nMaxDestSize, szSrc);
    }
    else
    {
        strncpy_s(szDest, nMaxDestSize, szSrc, nMaxDestSize);
        szDest[nMaxDestSize-1] = '';
    }
}

 // Получаем информацию о сбое программы
//
CrashInfo GetCrashInfo(const EXCEPTION_RECORD *pRecord)
{
    CrashInfo crashinfo;
    SafeStrCpy(crashinfo.Address, MAX_ADDRESS_LENGTH, "N/A");
    SafeStrCpy(crashinfo.ErrorCode, MAX_ADDRESS_LENGTH, "N/A");
    SafeStrCpy(crashinfo.Flags, MAX_ADDRESS_LENGTH, "N/A");

    sprintf_s(crashinfo.Address, "%08X", pRecord->ExceptionAddress);
    sprintf_s(crashinfo.ErrorCode, "%08X", pRecord->ExceptionCode);
    sprintf_s(crashinfo.Flags, "%08X", pRecord->ExceptionFlags);

    return crashinfo;
}

 // Получение информации CallStack
//
vector<CallStackInfo> GetCallStack(const CONTEXT *pContext)
{
    HANDLE hProcess = GetCurrentProcess();

    SymInitialize(hProcess, NULL, TRUE);

    vector<CallStackInfo> arrCallStackInfo;

    CONTEXT c = *pContext;

    STACKFRAME64 sf;
    memset(&sf, 0, sizeof(STACKFRAME64));
    DWORD dwImageType = IMAGE_FILE_MACHINE_I386;

         // Различные типы ЦП, конкретную информацию можно найти в MSDN
    //
#ifdef _M_IX86
    sf.AddrPC.Offset = c.Eip;
    sf.AddrPC.Mode = AddrModeFlat;
    sf.AddrStack.Offset = c.Esp;
    sf.AddrStack.Mode = AddrModeFlat;
    sf.AddrFrame.Offset = c.Ebp;
    sf.AddrFrame.Mode = AddrModeFlat;
#elif _M_X64
    dwImageType = IMAGE_FILE_MACHINE_AMD64;
    sf.AddrPC.Offset = c.Rip;
    sf.AddrPC.Mode = AddrModeFlat;
    sf.AddrFrame.Offset = c.Rsp;
    sf.AddrFrame.Mode = AddrModeFlat;
    sf.AddrStack.Offset = c.Rsp;
    sf.AddrStack.Mode = AddrModeFlat;
#elif _M_IA64
    dwImageType = IMAGE_FILE_MACHINE_IA64;
    sf.AddrPC.Offset = c.StIIP;
    sf.AddrPC.Mode = AddrModeFlat;
    sf.AddrFrame.Offset = c.IntSp;
    sf.AddrFrame.Mode = AddrModeFlat;
    sf.AddrBStore.Offset = c.RsBSP;
    sf.AddrBStore.Mode = AddrModeFlat;
    sf.AddrStack.Offset = c.IntSp;
    sf.AddrStack.Mode = AddrModeFlat;
#else
    #error "Platform not supported!"
#endif

    HANDLE hThread = GetCurrentThread();

    while (true)
    {
                 // Эта функция - самая важная функция для реализации этой функции
                 // Использование функции и конкретное объяснение параметров и возвращаемых значений можно найти на MSDN
        //
        if (!StackWalk64(dwImageType, hProcess, hThread, &sf, &c, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))
        {
            break;
        }

        if (sf.AddrFrame.Offset == 0)
        {
            break;
        }

        CallStackInfo callstackinfo;
        SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, "N/A");
        SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, "N/A");
        SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, "N/A");
        SafeStrCpy(callstackinfo.LineNumber, MAX_NAME_LENGTH, "N/A");

        BYTE symbolBuffer[sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH];
        IMAGEHLP_SYMBOL64 *pSymbol = (IMAGEHLP_SYMBOL64*)symbolBuffer;
        memset(pSymbol, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH);

        pSymbol->SizeOfStruct = sizeof(symbolBuffer);
        pSymbol->MaxNameLength = MAX_NAME_LENGTH;

        DWORD symDisplacement = 0;

                 // получаем имя функции
        //
        if (SymGetSymFromAddr64(hProcess, sf.AddrPC.Offset, NULL, pSymbol))
        {
            SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, pSymbol->Name);
        }

        IMAGEHLP_LINE64 lineInfo;
        memset(&lineInfo, 0, sizeof(IMAGEHLP_LINE64));

        lineInfo.SizeOfStruct = sizeof(IMAGEHLP_LINE64);

        DWORD dwLineDisplacement;

                 // Получаем имя файла и строку кода
        //
        if (SymGetLineFromAddr64(hProcess, sf.AddrPC.Offset, &dwLineDisplacement, &lineInfo))
        {
            SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, lineInfo.FileName);
            sprintf_s(callstackinfo.LineNumber, "%d", lineInfo.LineNumber);
        }

        IMAGEHLP_MODULE64 moduleInfo;
        memset(&moduleInfo, 0, sizeof(IMAGEHLP_MODULE64));

        moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);

                 // получаем имя модуля
        //
        if (SymGetModuleInfo64(hProcess, sf.AddrPC.Offset, &moduleInfo))
        {
            SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, moduleInfo.ModuleName);
        }

        arrCallStackInfo.push_back(callstackinfo);
    }

    SymCleanup(hProcess);

    return arrCallStackInfo;
}

LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException)
{
         // Убедитесь, что в стеке достаточно места
    //
#ifdef _M_IX86
    if (pException->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW)
    {
        static char TempStack[1024 * 128];
        __asm mov eax,offset TempStack[1024 * 128];
        __asm mov esp,eax;
    }
#endif

    CrashInfo crashinfo = GetCrashInfo(pException->ExceptionRecord);

         // Выводим информацию о сбое
    //
    cout << "ErrorCode: " << crashinfo.ErrorCode << endl;
    cout << "Address: " << crashinfo.Address << endl;
    cout << "Flags: " << crashinfo.Flags << endl;

    vector<CallStackInfo> arrCallStackInfo = GetCallStack(pException->ContextRecord);

         // Вывод CallStack
    //
    cout << "CallStack: " << endl;
    for (vector<CallStackInfo>::iterator i = arrCallStackInfo.begin(); i != arrCallStackInfo.end(); ++i)
    {
        CallStackInfo callstackinfo = (*i);

        cout << callstackinfo.MethodName << "() : [" << callstackinfo.ModuleName << "] (File: " << callstackinfo.FileName << " @Line " << callstackinfo.LineNumber << ")" << endl;
    }

         // Открываем диалоговое окно с ошибкой и выходим из программы
    //
    FatalAppExit(-1,  L"*** Unhandled Exception! ***");

    return EXCEPTION_EXECUTE_HANDLER;
}

void printStack( void )
{
    unsigned int   i;
    void         * stack[ 100 ];
    unsigned short frames;
    SYMBOL_INFO  * symbol;
    HANDLE         process;

    process = GetCurrentProcess();

    SymInitialize( process, NULL, TRUE );

    frames               = CaptureStackBackTrace( 0, 100, stack, NULL );
    symbol               = ( SYMBOL_INFO * )calloc( sizeof( SYMBOL_INFO ) + 256 * sizeof( char ), 1 );
    symbol->MaxNameLen   = 255;
    symbol->SizeOfStruct = sizeof( SYMBOL_INFO );

    for( i = 0; i < frames; i++ )
    {
        SymFromAddr( process, ( DWORD64 )( stack[ i ] ), 0, symbol );

        printf( "%i: %s - 0x%0Xn", frames - i - 1, symbol->Name, symbol->Address );
    }

    free( symbol );
}

Добавьте в файл .pro

CONFIG += console

CONFIG -= app_bundle

#dbghelp

LIBS += dbghelp.lib

Добавьте при входе в функцию mian:

    // Настройка обработки Unhandled Функция обратного вызова исключения

    //

    SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)ApplicationCrashHandler);

Будет распечатано место сбоя программы: