内存访问冲突

雪未成型 2016-05-09 06:46:56
0x006493E4 (cxcore.dll) (BayesNetAplication.exe 中)处有未经处理的异常: 0xC0000005: 执行位置 0x006493E4 时发生访问冲突。错误如图：

可能是什么原因导致 的呢？
...全文
595 20 打赏 收藏 转发到动态 举报
写回复
用AI写文章
20 条回复
切换为时间正序
请发表友善的回复…
发表回复
bsnry 2016-05-10
  • 打赏
  • 举报
 回复
引用 15 楼 u010925938 的回复:
问题补充：当点击中断时，会出现如下图所示的情况： 根本就没有办法单步调试，当在main函数中的第一条语句加断点，刚运行就会出现如第一次发的图的那个错误。
理解， 1. 调试器配置的不对导致的， 找不到pdb， 2. 尽量不要通过ide自己跳入进去看堆栈，学着通过日志分析解决问题，不过已经晚了，这个对楼主来说，不现实。
雪未成型 2016-05-10
  • 打赏
  • 举报
 回复
问题补充：当点击中断时，会出现如下图所示的情况：

根本就没有办法单步调试，当在main函数中的第一条语句加断点，刚运行就会出现如第一次发的图的那个错误。
ClientDC 2016-05-10
  • 打赏
  • 举报
 回复
一般都是内存越界或使用了已经销毁的指针，这种问题比较难查，出问题的代码段和报错的代码段一般都不在一个地方。
bsnry 2016-05-10
  • 打赏
  • 举报
 回复
引用 19 楼 u010925938 的回复:
[quote=引用 16 楼 bsnry 的回复:] [quote=引用 15 楼 u010925938 的回复:] 问题补充：当点击中断时，会出现如下图所示的情况： 根本就没有办法单步调试，当在main函数中的第一条语句加断点，刚运行就会出现如第一次发的图的那个错误。
理解， 1. 调试器配置的不对导致的， 找不到pdb， 2. 尽量不要通过ide自己跳入进去看堆栈，学着通过日志分析解决问题，不过已经晚了，这个对楼主来说，不现实。 [/quote] 如何正确配置调试器呢？谢谢[/quote] 不知道， 一遍不需要你配置，vs自动就可以做到， 但是你的很明显是没有配置好导致进入错误堆栈！！！ 以我的经验有这么几个可能： 1. 代码里有第三方库，对方只给你dll 2. 你的代码编译成debug 3. pdb文件是就是一种符号文件， 要调试的话， 必须有pdb，才能看到堆栈信息。 这就是为什么 微软有符号服务器，很多人从网上下载微软的符号， 自己搜 pdb符号服务器，这几个关键字。
雪未成型 2016-05-10
  • 打赏
  • 举报
 回复
引用 16 楼 bsnry 的回复:
[quote=引用 15 楼 u010925938 的回复:] 问题补充：当点击中断时，会出现如下图所示的情况： 根本就没有办法单步调试，当在main函数中的第一条语句加断点，刚运行就会出现如第一次发的图的那个错误。
理解， 1. 调试器配置的不对导致的， 找不到pdb， 2. 尽量不要通过ide自己跳入进去看堆栈，学着通过日志分析解决问题，不过已经晚了，这个对楼主来说，不现实。 [/quote] 如何正确配置调试器呢？谢谢
bsnry 2016-05-10
  • 打赏
  • 举报
 回复
引用 17 楼 zhao4zhong1 的回复:
应付不了的时候不还有后招吗？ 判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 
#include <time.h>
#include <stdlib.h>
#include <windows.h>
int main() {
    int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]

    srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。
    while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。
        b[(a=rand()%11)]=0;
        Sleep(100);
        b[(a=rand()%11)]=1;
        Sleep(100);
        b[(a=rand()%11)]=2;
        Sleep(100);
        b[(a=rand()%11)]=3;
        Sleep(100);
        b[(a=rand()%11)]=4;
        Sleep(100);
    }
    return 0;
}
有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成core文件、……这些方法都不行！ 写日志到文件参考下面： 
//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,
//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，
//在处理的时候每次从新buffer中取两个字节打印
#ifdef _MSC_VER
    #pragma warning(disable:4996)
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _MSC_VER
    #include <windows.h>
    #include <process.h>
    #include <io.h>
    #define  MYVOID             void
    #define  vsnprintf          _vsnprintf
#else
    #include <unistd.h>
    #include <sys/time.h>
    #include <pthread.h>
    #define  CRITICAL_SECTION   pthread_mutex_t
    #define  MYVOID             void *
#endif
//Log{
#define MAXLOGSIZE 20000000
#define MAXLINSIZE 16000
#include <time.h>
#include <sys/timeb.h>
#include <stdarg.h>
char logfilename1[]="MyLog1.log";
char logfilename2[]="MyLog2.log";
static char logstr[MAXLINSIZE+1];
char datestr[16];
char timestr[16];
char mss[4];
CRITICAL_SECTION cs_log;
FILE *flog;
#ifdef _MSC_VER
void Lock(CRITICAL_SECTION *l) {
    EnterCriticalSection(l);
}
void Unlock(CRITICAL_SECTION *l) {
    LeaveCriticalSection(l);
}
void sleep_ms(int ms) {
    Sleep(ms);
}
#else
void Lock(CRITICAL_SECTION *l) {
    pthread_mutex_lock(l);
}
void Unlock(CRITICAL_SECTION *l) {
    pthread_mutex_unlock(l);
}
void sleep_ms(int ms) {
    usleep(ms*1000);
}
#endif
void LogV(const char *pszFmt,va_list argp) {
    struct tm *now;
    struct timeb tb;

    if (NULL==pszFmt||0==pszFmt[0]) return;
    vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);
    ftime(&tb);
    now=localtime(&tb.time);
    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);
    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );
    sprintf(mss,"%03d",tb.millitm);
    printf("%s %s.%s %s",datestr,timestr,mss,logstr);
    flog=fopen(logfilename1,"a");
    if (NULL!=flog) {
        fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);
        if (ftell(flog)>MAXLOGSIZE) {
            fclose(flog);
            if (rename(logfilename1,logfilename2)) {
                remove(logfilename2);
                rename(logfilename1,logfilename2);
            }
        } else {
            fclose(flog);
        }
    }
}
void Log(const char *pszFmt,...) {
    va_list argp;

    Lock(&cs_log);
    va_start(argp,pszFmt);
    LogV(pszFmt,argp);
    va_end(argp);
    Unlock(&cs_log);
}
//Log}
#define ASIZE    200
#define BSIZE    240
#define CSIZE      2
char Abuf[ASIZE];
char Cbuf[CSIZE];
CRITICAL_SECTION cs_HEX ;
CRITICAL_SECTION cs_BBB ;
struct FIFO_BUFFER {
    int  head;
    int  tail;
    int  size;
    char data[BSIZE];
} BBB;
int No_Loop=0;
void HexDump(int cn,char *buf,int len) {
    int i,j,k;
    char binstr[80];

    Lock(&cs_HEX);
    for (i=0;i<len;i++) {
        if (0==(i%16)) {
            sprintf(binstr,"%03d %04x -",cn,i);
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
        } else if (15==(i%16)) {
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
            sprintf(binstr,"%s  ",binstr);
            for (j=i-15;j<=i;j++) {
                sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
            }
            Log("%s\n",binstr);
        } else {
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
        }
    }
    if (0!=(i%16)) {
        k=16-(i%16);
        for (j=0;j<k;j++) {
            sprintf(binstr,"%s   ",binstr);
        }
        sprintf(binstr,"%s  ",binstr);
        k=16-k;
        for (j=i-k;j<i;j++) {
            sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
        }
        Log("%s\n",binstr);
    }
    Unlock(&cs_HEX);
}
int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {
    int lent,len1,len2;

    lent=0;
    Lock(cs);
    if (fbuf->size>=len) {
        lent=len;
        if (fbuf->head+lent>BSIZE) {
            len1=BSIZE-fbuf->head;
            memcpy(buf     ,fbuf->data+fbuf->head,len1);
            len2=lent-len1;
            memcpy(buf+len1,fbuf->data           ,len2);
            fbuf->head=len2;
        } else {
            memcpy(buf     ,fbuf->data+fbuf->head,lent);
            fbuf->head+=lent;
        }
        fbuf->size-=lent;
    }
    Unlock(cs);
    return lent;
}
MYVOID thdB(void *pcn) {
    char        *recv_buf;
    int          recv_nbytes;
    int          cn;
    int          wc;
    int          pb;

    cn=(int)pcn;
    Log("%03d thdB              thread begin...\n",cn);
    while (1) {
        sleep_ms(10);
        recv_buf=(char *)Cbuf;
        recv_nbytes=CSIZE;
        wc=0;
        while (1) {
            pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);
            if (pb) {
                Log("%03d recv %d bytes\n",cn,pb);
                HexDump(cn,recv_buf,pb);
                sleep_ms(1);
            } else {
                sleep_ms(1000);
            }
            if (No_Loop) break;//
            wc++;
            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
        }
        if (No_Loop) break;//
    }
#ifndef _MSC_VER
    pthread_exit(NULL);
#endif
}
int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {
    int lent,len1,len2;

    Lock(cs);
    lent=len;
    if (fbuf->size+lent>BSIZE) {
        lent=BSIZE-fbuf->size;
    }
    if (fbuf->tail+lent>BSIZE) {
        len1=BSIZE-fbuf->tail;
        memcpy(fbuf->data+fbuf->tail,buf     ,len1);
        len2=lent-len1;
        memcpy(fbuf->data           ,buf+len1,len2);
        fbuf->tail=len2;
    } else {
        memcpy(fbuf->data+fbuf->tail,buf     ,lent);
        fbuf->tail+=lent;
    }
    fbuf->size+=lent;
    Unlock(cs);
    return lent;
}
MYVOID thdA(void *pcn) {
    char        *send_buf;
    int          send_nbytes;
    int          cn;
    int          wc;
    int           a;
    int          pa;

    cn=(int)pcn;
    Log("%03d thdA              thread begin...\n",cn);
    a=0;
    while (1) {
        sleep_ms(100);
        memset(Abuf,a,ASIZE);
        a=(a+1)%256;
        if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop
        send_buf=(char *)Abuf;
        send_nbytes=ASIZE;
        Log("%03d sending %d bytes\n",cn,send_nbytes);
        HexDump(cn,send_buf,send_nbytes);
        wc=0;
        while (1) {
            pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);
            Log("%03d sent %d bytes\n",cn,pa);
            HexDump(cn,send_buf,pa);
            send_buf+=pa;
            send_nbytes-=pa;
            if (send_nbytes<=0) break;//
            sleep_ms(1000);
            if (No_Loop) break;//
            wc++;
            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
        }
        if (No_Loop) break;//
    }
#ifndef _MSC_VER
    pthread_exit(NULL);
#endif
}
int main() {
#ifdef _MSC_VER
    InitializeCriticalSection(&cs_log);
    InitializeCriticalSection(&cs_HEX );
    InitializeCriticalSection(&cs_BBB );
#else
    pthread_t threads[2];
    int threadsN;
    int rc;
    pthread_mutex_init(&cs_log,NULL);
    pthread_mutex_init(&cs_HEX,NULL);
    pthread_mutex_init(&cs_BBB,NULL);
#endif
    Log("Start===========================================================\n");

    BBB.head=0;
    BBB.tail=0;
    BBB.size=0;

#ifdef _MSC_VER
    _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);
    _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2);
#else
    threadsN=0;
    rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
    rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
#endif

    if (!access("No_Loop",0)) {
        remove("No_Loop");
        if (!access("No_Loop",0)) {
            No_Loop=1;
        }
    }
    while (1) {
        sleep_ms(1000);
        if (No_Loop) break;//
        if (!access("No_Loop",0)) {
            No_Loop=1;
        }
    }
    sleep_ms(3000);
    Log("End=============================================================\n");
#ifdef _MSC_VER
    DeleteCriticalSection(&cs_BBB );
    DeleteCriticalSection(&cs_HEX );
    DeleteCriticalSection(&cs_log);
#else
    pthread_mutex_destroy(&cs_BBB);
    pthread_mutex_destroy(&cs_HEX);
    pthread_mutex_destroy(&cs_log);
#endif
    return 0;
}
这种方法只能应付每次必现的bug ！！！ 日志这才杀器
赵4老师 2016-05-10
  • 打赏
  • 举报
 回复
应付不了的时候不还有后招吗？ 判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 
#include <time.h>
#include <stdlib.h>
#include <windows.h>
int main() {
    int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]

    srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。
    while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。
        b[(a=rand()%11)]=0;
        Sleep(100);
        b[(a=rand()%11)]=1;
        Sleep(100);
        b[(a=rand()%11)]=2;
        Sleep(100);
        b[(a=rand()%11)]=3;
        Sleep(100);
        b[(a=rand()%11)]=4;
        Sleep(100);
    }
    return 0;
}
有时不将“调用函数名字＋各参数值，进入函数后各参数值，中间变量值，退出函数前准备返回的值，返回函数到调用处后函数名字＋各参数值＋返回值”这些信息写日志到文件中是无论如何也发现不了问题在哪里的，包括捕获各种异常、写日志到屏幕、单步或设断点或生成core文件、……这些方法都不行！ 写日志到文件参考下面： 
//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,
//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，
//在处理的时候每次从新buffer中取两个字节打印
#ifdef _MSC_VER
    #pragma warning(disable:4996)
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _MSC_VER
    #include <windows.h>
    #include <process.h>
    #include <io.h>
    #define  MYVOID             void
    #define  vsnprintf          _vsnprintf
#else
    #include <unistd.h>
    #include <sys/time.h>
    #include <pthread.h>
    #define  CRITICAL_SECTION   pthread_mutex_t
    #define  MYVOID             void *
#endif
//Log{
#define MAXLOGSIZE 20000000
#define MAXLINSIZE 16000
#include <time.h>
#include <sys/timeb.h>
#include <stdarg.h>
char logfilename1[]="MyLog1.log";
char logfilename2[]="MyLog2.log";
static char logstr[MAXLINSIZE+1];
char datestr[16];
char timestr[16];
char mss[4];
CRITICAL_SECTION cs_log;
FILE *flog;
#ifdef _MSC_VER
void Lock(CRITICAL_SECTION *l) {
    EnterCriticalSection(l);
}
void Unlock(CRITICAL_SECTION *l) {
    LeaveCriticalSection(l);
}
void sleep_ms(int ms) {
    Sleep(ms);
}
#else
void Lock(CRITICAL_SECTION *l) {
    pthread_mutex_lock(l);
}
void Unlock(CRITICAL_SECTION *l) {
    pthread_mutex_unlock(l);
}
void sleep_ms(int ms) {
    usleep(ms*1000);
}
#endif
void LogV(const char *pszFmt,va_list argp) {
    struct tm *now;
    struct timeb tb;

    if (NULL==pszFmt||0==pszFmt[0]) return;
    vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);
    ftime(&tb);
    now=localtime(&tb.time);
    sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);
    sprintf(timestr,"%02d:%02d:%02d",now->tm_hour     ,now->tm_min  ,now->tm_sec );
    sprintf(mss,"%03d",tb.millitm);
    printf("%s %s.%s %s",datestr,timestr,mss,logstr);
    flog=fopen(logfilename1,"a");
    if (NULL!=flog) {
        fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);
        if (ftell(flog)>MAXLOGSIZE) {
            fclose(flog);
            if (rename(logfilename1,logfilename2)) {
                remove(logfilename2);
                rename(logfilename1,logfilename2);
            }
        } else {
            fclose(flog);
        }
    }
}
void Log(const char *pszFmt,...) {
    va_list argp;

    Lock(&cs_log);
    va_start(argp,pszFmt);
    LogV(pszFmt,argp);
    va_end(argp);
    Unlock(&cs_log);
}
//Log}
#define ASIZE    200
#define BSIZE    240
#define CSIZE      2
char Abuf[ASIZE];
char Cbuf[CSIZE];
CRITICAL_SECTION cs_HEX ;
CRITICAL_SECTION cs_BBB ;
struct FIFO_BUFFER {
    int  head;
    int  tail;
    int  size;
    char data[BSIZE];
} BBB;
int No_Loop=0;
void HexDump(int cn,char *buf,int len) {
    int i,j,k;
    char binstr[80];

    Lock(&cs_HEX);
    for (i=0;i<len;i++) {
        if (0==(i%16)) {
            sprintf(binstr,"%03d %04x -",cn,i);
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
        } else if (15==(i%16)) {
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
            sprintf(binstr,"%s  ",binstr);
            for (j=i-15;j<=i;j++) {
                sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
            }
            Log("%s\n",binstr);
        } else {
            sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
        }
    }
    if (0!=(i%16)) {
        k=16-(i%16);
        for (j=0;j<k;j++) {
            sprintf(binstr,"%s   ",binstr);
        }
        sprintf(binstr,"%s  ",binstr);
        k=16-k;
        for (j=i-k;j<i;j++) {
            sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
        }
        Log("%s\n",binstr);
    }
    Unlock(&cs_HEX);
}
int GetFromRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {
    int lent,len1,len2;

    lent=0;
    Lock(cs);
    if (fbuf->size>=len) {
        lent=len;
        if (fbuf->head+lent>BSIZE) {
            len1=BSIZE-fbuf->head;
            memcpy(buf     ,fbuf->data+fbuf->head,len1);
            len2=lent-len1;
            memcpy(buf+len1,fbuf->data           ,len2);
            fbuf->head=len2;
        } else {
            memcpy(buf     ,fbuf->data+fbuf->head,lent);
            fbuf->head+=lent;
        }
        fbuf->size-=lent;
    }
    Unlock(cs);
    return lent;
}
MYVOID thdB(void *pcn) {
    char        *recv_buf;
    int          recv_nbytes;
    int          cn;
    int          wc;
    int          pb;

    cn=(int)pcn;
    Log("%03d thdB              thread begin...\n",cn);
    while (1) {
        sleep_ms(10);
        recv_buf=(char *)Cbuf;
        recv_nbytes=CSIZE;
        wc=0;
        while (1) {
            pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);
            if (pb) {
                Log("%03d recv %d bytes\n",cn,pb);
                HexDump(cn,recv_buf,pb);
                sleep_ms(1);
            } else {
                sleep_ms(1000);
            }
            if (No_Loop) break;//
            wc++;
            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
        }
        if (No_Loop) break;//
    }
#ifndef _MSC_VER
    pthread_exit(NULL);
#endif
}
int PutToRBuf(int cn,CRITICAL_SECTION *cs,struct FIFO_BUFFER *fbuf,char *buf,int len) {
    int lent,len1,len2;

    Lock(cs);
    lent=len;
    if (fbuf->size+lent>BSIZE) {
        lent=BSIZE-fbuf->size;
    }
    if (fbuf->tail+lent>BSIZE) {
        len1=BSIZE-fbuf->tail;
        memcpy(fbuf->data+fbuf->tail,buf     ,len1);
        len2=lent-len1;
        memcpy(fbuf->data           ,buf+len1,len2);
        fbuf->tail=len2;
    } else {
        memcpy(fbuf->data+fbuf->tail,buf     ,lent);
        fbuf->tail+=lent;
    }
    fbuf->size+=lent;
    Unlock(cs);
    return lent;
}
MYVOID thdA(void *pcn) {
    char        *send_buf;
    int          send_nbytes;
    int          cn;
    int          wc;
    int           a;
    int          pa;

    cn=(int)pcn;
    Log("%03d thdA              thread begin...\n",cn);
    a=0;
    while (1) {
        sleep_ms(100);
        memset(Abuf,a,ASIZE);
        a=(a+1)%256;
        if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop
        send_buf=(char *)Abuf;
        send_nbytes=ASIZE;
        Log("%03d sending %d bytes\n",cn,send_nbytes);
        HexDump(cn,send_buf,send_nbytes);
        wc=0;
        while (1) {
            pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);
            Log("%03d sent %d bytes\n",cn,pa);
            HexDump(cn,send_buf,pa);
            send_buf+=pa;
            send_nbytes-=pa;
            if (send_nbytes<=0) break;//
            sleep_ms(1000);
            if (No_Loop) break;//
            wc++;
            if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
        }
        if (No_Loop) break;//
    }
#ifndef _MSC_VER
    pthread_exit(NULL);
#endif
}
int main() {
#ifdef _MSC_VER
    InitializeCriticalSection(&cs_log);
    InitializeCriticalSection(&cs_HEX );
    InitializeCriticalSection(&cs_BBB );
#else
    pthread_t threads[2];
    int threadsN;
    int rc;
    pthread_mutex_init(&cs_log,NULL);
    pthread_mutex_init(&cs_HEX,NULL);
    pthread_mutex_init(&cs_BBB,NULL);
#endif
    Log("Start===========================================================\n");

    BBB.head=0;
    BBB.tail=0;
    BBB.size=0;

#ifdef _MSC_VER
    _beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);
    _beginthread((void(__cdecl *)(void *))thdB,0,(void *)2);
#else
    threadsN=0;
    rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
    rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
#endif

    if (!access("No_Loop",0)) {
        remove("No_Loop");
        if (!access("No_Loop",0)) {
            No_Loop=1;
        }
    }
    while (1) {
        sleep_ms(1000);
        if (No_Loop) break;//
        if (!access("No_Loop",0)) {
            No_Loop=1;
        }
    }
    sleep_ms(3000);
    Log("End=============================================================\n");
#ifdef _MSC_VER
    DeleteCriticalSection(&cs_BBB );
    DeleteCriticalSection(&cs_HEX );
    DeleteCriticalSection(&cs_log);
#else
    pthread_mutex_destroy(&cs_BBB);
    pthread_mutex_destroy(&cs_HEX);
    pthread_mutex_destroy(&cs_log);
#endif
    return 0;
}
bsnry 2016-05-09
  • 打赏
  • 举报
 回复
引用 12 楼 yshuise 的回复:
本人靠debug和boundschecker解决bug，很久以前了。
我感觉 只能解决一部分， 即使你做了单元测试！！！
yshuise 2016-05-09
  • 打赏
  • 举报
 回复
本人靠debug和boundschecker解决bug，很久以前了。
bsnry 2016-05-09
  • 打赏
  • 举报
 回复
引用 9 楼 u010925938 的回复:
[quote=引用 6 楼 bsnry 的回复:] [quote=引用 4 楼 bsnry 的回复:] [quote=引用 3 楼 qq423399099 的回复:] 爆栈爆堆访问野指针（即已释放的指针）都可能引发 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。
这是老赵的，只能应付部分情况，很多应付不了。 我个人觉得： １.　开启ｄｅｂｕｇ级别日志 ２.　最好是日志覆盖率搞， 3. 代码检测工具 我加过的c++代码，大多是没有日志的， 老是看到有人问—————— 为什么Debug版本没问题，release有问题，之类奇怪的问题。 [/quote] ide调试解决bug，这种方式，现场很难解决，也难于复现。 你觉得呢？[/quote] 谢谢，我尝试一下您说的方法[/quote]
引用 9 楼 u010925938 的回复:
[quote=引用 6 楼 bsnry 的回复:] [quote=引用 4 楼 bsnry 的回复:] [quote=引用 3 楼 qq423399099 的回复:] 爆栈爆堆访问野指针（即已释放的指针）都可能引发 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。
这是老赵的，只能应付部分情况，很多应付不了。 我个人觉得： １.　开启ｄｅｂｕｇ级别日志 ２.　最好是日志覆盖率搞， 3. 代码检测工具 我加过的c++代码，大多是没有日志的， 老是看到有人问—————— 为什么Debug版本没问题，release有问题，之类奇怪的问题。 [/quote] ide调试解决bug，这种方式，现场很难解决，也难于复现。 你觉得呢？[/quote] 谢谢，我尝试一下您说的方法[/quote] 好多机器上没有调试器，也不能装，不能破用户的机器， 日志打印代码走向，关键信息是必须的。 至于项目庞大，日志覆盖率多高，我自己也没经验 我只在小项目中用日志来解决问题。 庞大的c++项目，我自己也不是很会使用日志， 日志使用过多，代码量多，肯定通过日志分析代码，也是一块苦差事
纹枰老妖 2016-05-09
  • 打赏
  • 举报
 回复
引用 7 楼 u010925938 的回复:
[quote=引用 2 楼 wenpinglaoyao 的回复:] 楼主，您的代码程序里，有没有使用一些指向变量的指针呢？如果有的话，那就有这样一种可能：某个指针发生越界访问。 因为现在的主流编译器，会在变量之间填充一些多余地址空间，然后在这些空间里面写入某个特定值，最后机器会检查这些填充空间，如果里面的值和特定值不一致，则会出现您给出的错误提示框
确实有指针变量，这是git上一个关于PNL的一个项目，我在它的基础上，写个测试用例，我修改它的部分源码，它的源码之前是生成.dll提供接口使用的，我仅修改部分源码，但没有重新生成.dll。是不是这个也可能会有影响呢？（ps：之前没接触过比较大的项目）[/quote] 那建议您注意一下这些指针，比如，一个p++，之后再*p=“某个值"，就很有可能引发越界访问，因为这时的p就是指向的测试内存变量，而非程序使用变量【比如您定义两个相邻变量a、b，p本来指向a，p++之后指向的是测试变量，而非b】
雪未成型 2016-05-09
  • 打赏
  • 举报
 回复
引用 3 楼 qq423399099 的回复:
爆栈爆堆访问野指针（即已释放的指针）都可能引发 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。
说的很对，其实我也一直在调试在修改，这个代码也是调试了一周以上实在搞不定了，然后希望别人的建议能够启发一下。谢谢
雪未成型 2016-05-09
  • 打赏
  • 举报
 回复
引用 6 楼 bsnry 的回复:
[quote=引用 4 楼 bsnry 的回复:] [quote=引用 3 楼 qq423399099 的回复:] 爆栈爆堆访问野指针（即已释放的指针）都可能引发 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。
这是老赵的，只能应付部分情况，很多应付不了。 我个人觉得： １.　开启ｄｅｂｕｇ级别日志 ２.　最好是日志覆盖率搞， 3. 代码检测工具 我加过的c++代码，大多是没有日志的， 老是看到有人问—————— 为什么Debug版本没问题，release有问题，之类奇怪的问题。 [/quote] ide调试解决bug，这种方式，现场很难解决，也难于复现。 你觉得呢？[/quote] 谢谢，我尝试一下您说的方法
雪未成型 2016-05-09
  • 打赏
  • 举报
 回复
引用 2 楼 wenpinglaoyao 的回复:
楼主，您的代码程序里，有没有使用一些指向变量的指针呢？如果有的话，那就有这样一种可能：某个指针发生越界访问。 因为现在的主流编译器，会在变量之间填充一些多余地址空间，然后在这些空间里面写入某个特定值，最后机器会检查这些填充空间，如果里面的值和特定值不一致，则会出现您给出的错误提示框
确实有指针变量，这是git上一个关于PNL的一个项目，我在它的基础上，写个测试用例，我修改它的部分源码，它的源码之前是生成.dll提供接口使用的，我仅修改部分源码，但没有重新生成.dll。是不是这个也可能会有影响呢？（ps：之前没接触过比较大的项目）
雪未成型 2016-05-09
  • 打赏
  • 举报
 回复
引用 1 楼 bsnry 的回复:
[quote=引用 楼主 u010925938 的回复:] 0x006493E4 (cxcore.dll) (BayesNetAplication.exe 中)处有未经处理的异常: 0xC0000005: 执行位置 0x006493E4 时发生访问冲突。错误如图： 可能是什么原因导致 的呢？
Visual Leak Detector 试试这个 [/quote] 好，我下载尝试一下。
bsnry 2016-05-09
  • 打赏
  • 举报
 回复
引用 3 楼 qq423399099 的回复:
爆栈爆堆访问野指针（即已释放的指针）都可能引发 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。
这是老赵的，只能应付部分情况，很多应付不了。 我个人觉得： １.　开启ｄｅｂｕｇ级别日志 ２.　最好是日志覆盖率搞， 3. 代码检测工具 我加过的c++代码，大多是没有日志的， 老是看到有人问—————— 为什么Debug版本没问题，release有问题，之类奇怪的问题。
bsnry 2016-05-09
  • 打赏
  • 举报
 回复
引用 4 楼 bsnry 的回复:
[quote=引用 3 楼 qq423399099 的回复:] 爆栈爆堆访问野指针（即已释放的指针）都可能引发 崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。 代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。
这是老赵的，只能应付部分情况，很多应付不了。 我个人觉得： １.　开启ｄｅｂｕｇ级别日志 ２.　最好是日志覆盖率搞， 3. 代码检测工具 我加过的c++代码，大多是没有日志的， 老是看到有人问—————— 为什么Debug版本没问题，release有问题，之类奇怪的问题。 [/quote] ide调试解决bug，这种方式，现场很难解决，也难于复现。 你觉得呢？
小灸舞 2016-05-09
  • 打赏
  • 举报
 回复
爆栈爆堆访问野指针（即已释放的指针）都可能引发
崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。
提醒：再牛×的老师也无法代替学生自己领悟和上厕所！
单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。
纹枰老妖 2016-05-09
  • 打赏
  • 举报
 回复
楼主，您的代码程序里，有没有使用一些指向变量的指针呢？如果有的话，那就有这样一种可能：某个指针发生越界访问。 因为现在的主流编译器，会在变量之间填充一些多余地址空间，然后在这些空间里面写入某个特定值，最后机器会检查这些填充空间，如果里面的值和特定值不一致，则会出现您给出的错误提示框
bsnry 2016-05-09
  • 打赏
  • 举报
 回复
引用 楼主 u010925938 的回复:
0x006493E4 (cxcore.dll) (BayesNetAplication.exe 中)处有未经处理的异常: 0xC0000005: 执行位置 0x006493E4 时发生访问冲突。错误如图： 可能是什么原因导致 的呢？
Visual Leak Detector 试试这个
项目经理的冲突管理方法
之前有人跟我说，坚决不当项目经理，当项目经理要生的气太多了，他觉得会折寿。为了解决这个折寿的问题，特意给大家开发了《成为项目经理的方法》的后续课程《项目经理的冲突管理方法》，给大家提供在管理项目的过程中可能遇到的冲突的解决方法，包括自己与别人发生的冲突、下属之间的冲突以及小组之间的冲突。当然了，解决冲突，就必须的涉及到情绪的处理，所以也给出了让自己平静下来的4个方法，还有让对方平静下来的3句有魔力的话，一起来看看啊~
使用Mat数据时，内存访问冲突（记一次头秃的使用Mat传参的经历）
1. 错误描述 环境：openCV 3.4.9 vs 2015 最近在使用opencv Mat数据时遇到一个秃头的内存访问数据错误。 在跨文件（从一个类传给另外一个类）使用Mat数据时发生内存访问冲突的错误，（此处头发减一） 百思不得其解，挠落无数头发（hair - -）才发现， 读取数据的时候出了问题。imread(filename,0);和imread(filename);有着天壤之别。 imread第二个参数缺省值为1，表示按彩色（三通道）图像读入数据，（哪怕你原图只有两个通道） ..
读取位置时发生内存访问冲突
访问位置冲突异常通常是由以下几种原因引起的：
C++ 内存访问冲突错误
（1）数组越界 （2）指针未定义
C++ 语言

64,684

社区成员

250,491

社区内容

发帖
与我相关
我的任务
社区描述
C++ 语言相关问题讨论，技术干货分享，前沿动态等
c++ 技术论坛（原bbs）
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题，如果涉及到代码请尽可能的格式化一下

试试用AI创作助手写篇文章吧

+ 用AI写文章