vc6.0缓冲区

头文件中:

1,定义缓冲区数组。。

//char *Device_pCirBuf;//环形缓冲区
    BYTE Device_pCirBuf[81];//环形缓冲区

cpp文件中

2,定义缓冲区接收长度,接收正确数据包定义,读指针(缓冲区头),写指针(缓冲区尾)

char Device_rightdata[38];//保存数据包
int Device_size=81;//缓冲区长度
int Device_startPos,Device_endPos;

3,打开串口的时候,缓冲区指针清零。

    if(!m_ctrlComm.GetPortOpen())
    {
        m_ctrlComm.SetPortOpen(TRUE); //打开串口。
        GetDlgItem(IDC_OPEN_SERIS)->SetWindowText("请关闭串口");

        m_ctrlIconOpenoff.SetIcon(m_hIconOpen);

        //Device_pCirBuf = new char [Device_size]; 

        //memset(Device_pCirBuf, 0, Device_size);
        Device_startPos=0,Device_endPos=0;
    }

4,串口接收1个字节就触发接收事件。

m_ctrlComm.SetRThreshold(1); //每当缓冲区有多余或等于1个字符(字节)时引发一个接收的OnComm事件

5,接收触发事件

void CDevicedlg::OnOnCommMscomm1()
{
    // TODO: Add your control notification handler code here
    //UpdateData(TRUE);

     VARIANT variant_inp;
    COleSafeArray safearray_inp;
    LONG Device_len,Device_k;
    // 接收区
    int slen=0,r_d_len=38;
    BYTE recvdata[512];//定义存放二进制数据的数组
    CString str;
    if(m_ctrlComm.GetCommEvent() == 2) // 表示接收缓冲区内有字符
    {
            //    m_ctrlIconOpenoff.SetIcon(m_hIconOpen);
                 variant_inp=m_ctrlComm.GetInput(); // /读串口输入缓冲区
                //将VARAIANT变量赋值给COleSafeArray类的实例
                 safearray_inp=variant_inp;
                //使用COleSafeArray类的成员函数获取数据长度
                 Device_len=safearray_inp.GetOneDimSize();
                //使用COleSafeArray类的成员函数将数据写入数组
                 for(Device_k=0;Device_k<Device_len;Device_k++)
                     safearray_inp.GetElement(&Device_k,recvdata+Device_k); // 转换为BYTE数组  0-13
                 //从缓存取出,给新的字节型数组。
                 //根据长度来定义,新数组长度。
                //写循环缓冲区
                for (int i=0;i<Device_len;i++)
                {
                    Device_pCirBuf[Device_endPos]=recvdata[i];
                    Device_endPos++;//新的endPos位置
                    //endPos 从0-80可以存81个字节,当值为81时,应该从0开始
                    if(Device_endPos==Device_size)
                        Device_endPos=0;
                }
                //接收够了38个字节。
                if ((slen=Device_endPos>Device_startPos ? Device_endPos-Device_startPos : 80-Device_startPos+1+Device_endPos)>r_d_len-1)
                {
                    //找到帧头。
one:                if (Device_pCirBuf[Device_startPos]==(BYTE)0xA5 && Device_pCirBuf[Device_startPos+1>80 ? 0 : Device_startPos+1]==(BYTE)0xA9)
                    {
                        //帧头对,则从帧头位置取38个字节的完整帧。
                        for (int i=0; i<r_d_len; i++ )
                        {
                            //这个地方,缓存到80的时候,要变成0继续向38个字节的完整帧中写数据。
                            if (Device_startPos!=Device_size)
                            {
                                Device_rightdata[i]=Device_pCirBuf[Device_startPos];
                                Device_startPos++;
                            }
                            else
                            {
                                Device_startPos=0;
                                Device_rightdata[i]=Device_pCirBuf[Device_startPos];
                                Device_startPos++;
                            }

                        }
                        DataProcessing();

                    }
                    else
                    {
                        //继续找帧头,可能找到80后还没找到帧尾,应该从0开始找
                        if (Device_startPos+1==81)
                        {
                            Device_startPos=0;
                        }
                        else
                        {
                            Device_startPos++;
                        }
                        goto one;
                    }
                    //取完xx个完整帧后,重定位下一次读缓存的位置
                    Device_startPos=Device_endPos;
                }
    }
    for (int i=0; i<512; i++ )
    {
        recvdata[i]=0;
    }
//    m_ctrlIconOpenoff.SetIcon(m_hIconOff);
     UpdateData(false);
}

6,正确数据包处理

DataProcessing
void CDevicedlg::DataProcessing()
{
        BYTE rebuff;
        int k, R_D_LEN=38;
        CString str;
        bool judge;
        BYTE judge_sum;
        switch((BYTE)Device_rightdata[5])
        {

        case 2://
            {
                rebuff=0;
                //rebuff=*(char *)(recvdata+2);
                for(k=2;k<R_D_LEN-2;k=k+1)//校验
                {
                    rebuff=rebuff^(*(char *)(Device_rightdata+k));
                    //str.Format(_T("%c"),bt)
                }

                judge_sum=*(char *)(Device_rightdata+R_D_LEN-2);
                //校验不正确,肯定就不解析数据了,应该继续获取数据。
                if (judge_sum==rebuff)
                {
                    judge=true;
                }
                else
                {
                    judge=false;
                }
                if(judge)
                {
                    //解包并显示,解析第7,8个字节。x10, 1
                    for(k=7;k<9;k=k+2)
                    {
                        BYTE bt1=(*(char *)(Device_rightdata+k-1));
                        BYTE bt2=(*(char *)(Device_rightdata+k));
                        int bt=bt1*256+bt2;
                        float bt0=(float)((float)bt/1000);
                        //得到四位数                        

                        if (edit1==1)
                        {
                            m_u11=bt0;
                        }
                        if (edit2==1)
                        {
                            m_u12=bt0;
                        }
                        if (edit3==1)
                        {
                            m_u21=bt0;
                        }
                        if (edit4==1)
                        {
                            m_u22=bt0;
                        }
                    }
                    //解析第9,10个字节 , x20   6
                    for(k=9;k<11;k=k+2)
                    {
                        BYTE bt1=(*(char *)(Device_rightdata+k-1));
                        BYTE bt2=(*(char *)(Device_rightdata+k));
                        int bt=bt1*256+bt2;
                        float bt0=(float)((float)bt/1000);
                        //得到四位数    

                        if (edit1==1)
                        {
                            m_u13=bt0;
                        }
                        if (edit2==1)
                        {
                            m_u14=bt0;
                        }
                        if (edit3==1)
                        {
                            m_u23=bt0;
                        }
                        if (edit4==1)
                        {
                            m_u24=bt0;
                        }
                    }
                    //解析第11,12个字节。 x30
                    for(k=11;k<12;k=k+2)
                    {
                        BYTE bt1=(*(char *)(Device_rightdata+k-1));
                        BYTE bt2=(*(char *)(Device_rightdata+k));
                        int bt=bt1*256+bt2;
                        float bt0=(float)((float)bt/1000);
                        //得到四位数    

                        if (edit1==1)
                        {
                            m_u15=bt0;
                        }
                        if (edit2==1)
                        {
                            m_u16=bt0;
                        }
                        if (edit3==1)
                        {
                            m_u25=bt0;
                        }

                            if (edit4==1)
                            {
                                m_u26=bt0;
                            }                                

                        }
                    }
                    break;
                    }
                case 3://
                    {
                        rebuff=0;
                        //rebuff=*(char *)(recvdata+2);
                        for(k=2;k<R_D_LEN-2;k=k+1)//校验
                        {
                            rebuff=rebuff^(*(char *)(Device_rightdata+k));
                            //str.Format(_T("%c"),bt)
                        }
                        //校验通过,解析数据
                        if( rebuff==*(char *)(Device_rightdata+R_D_LEN-2))
                        {
                            //7 8 9是  a1解析3个字节  1
                            for(k=7;k<9;k=k+2)
                            {

                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));

                                float bt=(float)(bt2*256+bt3);
                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_a1=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_a1=(float)(bt/1000);
                                }

                                //得到四位数
                            }
                            //10 11 12  b1解析3个字节,2
                            for(k=10;k<12;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));

                                float bt=(float)(bt2*256+bt3);
                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_b1=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_b1=(float)(bt/1000);
                                }
                            }
                            //13 14 15 是  c1解析3个字节
                            for(k=13;k<15;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));
                                float bt=(float)(bt2*256+bt3);
                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_c1=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_c1=(float)((float)bt/1000);
                                }
                            }
                            //解析3个字节,

                            for(k=16;k<18;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1)); //
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));
                                float bt=(float)(bt2*256+bt3);
                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_a2=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_a2=(float)((float)bt/1000);
                                }
                                //得到四位数
                            }
                            //
                            for(k=19;k<21;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));

                                float bt=(float)(bt2*256+bt3);
                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_b2=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_b2=(float)((float)bt/1000);
                                }
                            }
                            //
                            for(k=22;k<23;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));
                                float bt=(float)(bt2*256+bt3);

                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_c2=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_c2=(float)((float)bt/1000);
                                }
                            }
                            //7
                            for(k=25;k<27;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));
                                float bt=(float)(bt2*256+bt3);

                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_a3=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_a3=(float)((float)bt/1000);
                                }
                                //得到四位数

                            }
                            //30 31 32  ,8
                            for(k=28;k<30;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));
                                float bt=(float)(bt2*256+bt3);

                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_b3=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_b3=(float)((float)bt/1000);
                                }
                            }
                            // 33 34 35是休眠时间间隔   9
                            for(k=31;k<33;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                BYTE bt3=(*(char *)(Device_rightdata+k+1));
                                float bt=(float)(bt2*256+bt3);
                                if ((*(char *)(Device_rightdata+k-1))==(char)0x80)
                                {
                                    m_set_c3=(float)(bt/1000*(-1));
                                }
                                else
                                {
                                    m_set_c3=(float)((float)bt/1000);
                                }
                            }
                        }
                        break;
                    }
                case 4://
                    {
                        rebuff=0;
                        //rebuff=*(char *)(recvdata+2);
                        for(k=2;k<R_D_LEN-2;k=k+1)//校验
                        {
                            rebuff=rebuff^(*(char *)(Device_rightdata+k));
                            //str.Format(_T("%c"),bt)
                        }
                        if( rebuff==*(char *)(Device_rightdata+R_D_LEN-2))
                        {
                            //
                            for(k=7;k<8;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                //int bt=bt1*256+bt2;

                                //得到四位数
                                str.Format("%d", bt1);
                                m_qianhao=(int)atoi(str);        

                            }
                            //
                            for(k=8;k<9;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                //    int bt=bt1*256+bt2;
                                //得到四位数
                                str.Format("%d", bt1);
                                m_xianxing=(int)atoi(str);                                

                            }
                            //9、10
                            for(k=9;k<10;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                float bt=(float)(bt1*256+bt2);
                                //得到四位数
                                m_xiumian_s=(float)(bt/1000);
                            }
                            for(k=12;k<13;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                float bt=(float)(bt1*256+bt2);
                                //得到四位数
                                m_y3_1=(float)(bt/1000);
                            }
                            for(k=14;k<15;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                float bt=(float)(bt1*256+bt2);
                                //得到四位数
                                m_y3_6=(float)(bt/1000);
                            }
                            for(k=16;k<17;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                float bt=(float)(bt1*256+bt2);
                                //得到四位数
                                m_y3_2=(float)(bt/1000);
                            }
                            for(k=18;k<19;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                float bt=(float)(bt1*256+bt2);
                                //得到四位数
                                m_y3_5=(float)(bt/1000);
                            }
                            for(k=20;k<21;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                float bt=(float)(bt1*256+bt2);
                                //得到四位数
                                m_y3_3=(float)(bt/1000);
                            }
                            for(k=22;k<23;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                float bt=(float)(bt1*256+bt2);
                                //得到四位数
                                m_y3_4=(float)(bt/1000);
                            }    

                        }
                        break;
                    }
                case 5://
                    {
                        AfxMessageBox("正确!");
                         break;
                    }
                case 6://
                    {
                        CByteArray m_Array;
                        m_Array.RemoveAll();
                        m_Array.SetSize(8);
                        m_Array.SetAt(0,0xA5);
                        m_Array.SetAt(1,0xA6);
                        m_Array.SetAt(2,0x08);
                        m_Array.SetAt(3,0xF5);  //
                        m_Array.SetAt(4,0xF6);  //
                        m_Array.SetAt(5,0x09);
                        m_Array.SetAt(6,0x02);
                        m_Array.SetAt(7,0xAD);
                        m_ctrlComm.SetOutput(COleVariant(m_Array));
                        break;
                    }
                case 7://
                    {
                        float bt=0;
                        rebuff=0;
                        //rebuff=*(char *)(recvdata+2);
                        for(k=2;k<R_D_LEN-2;k=k+1)//校验,k<36  (36)是校验位,所以计算的时候2到35,
                        {
                            rebuff=rebuff^((BYTE)(Device_rightdata[k]));
                            //str.Format(_T("%c"),bt)
                        }

                        if( rebuff==((BYTE)(Device_rightdata[36])))
                        {
                            //7是ID

                            for(k=7;k<8;k=k+2)
                            {
                                BYTE bt1=(*(char *)(Device_rightdata+k-1));
                                BYTE bt2=(*(char *)(Device_rightdata+k));
                                bt=(float)(bt1*256+bt2);
                                //得到四位数
                                bt=(float)(bt/1000);
                                if(disp_u1==1)
                                {
                                    m_u11=bt;

                                }
                                if(disp_u2==1)
                                {
                                    m_u12=bt;

                                }
                                if(disp_u3==1)
                                {
                                    m_u13=bt;

                                }
                                if(disp_u4==1)
                                {
                                    m_u14=bt;

                                }
                                if(disp_u5==1)
                                {
                                    m_u15=bt;

                                }
                                if(disp_u6==1)
                                {
                                    m_u16=bt;

                                }
                                if(disp_u7==1)
                                {
                                    m_u21=bt;

                                }
                                if(disp_u8==1)
                                {
                                    m_u22=bt;

                                }
                                if(disp_u9==1)
                                {
                                    m_u23=bt;

                                }
                                if(disp_u10==1)
                                {
                                    m_u24=bt;

                                }
                                if(disp_u11==1)
                                {
                                    m_u25=bt;

                                }
                                if(disp_u12==1)
                                {
                                    m_u26=bt;

                                }    

                                disp_u1=0;
                                disp_u2=0;
                                disp_u3=0;
                                disp_u4=0;
                                disp_u5=0;
                                disp_u6=0;
                                disp_u7=0;
                                disp_u8=0;
                                disp_u9=0;
                                disp_u10=0;
                                disp_u11=0;
                                disp_u12=0;

                            }
                        }
                        break;
                    }
                default:
                     break;
                 }
             UpdateData(false);
}

7,关闭串口的时候,指针清零。

    if(m_ctrlComm.GetPortOpen())
    {
        m_ctrlComm.SetPortOpen(FALSE);
        GetDlgItem(IDC_OPEN_SERIS)->SetWindowText("请打开串口");
        m_ctrlIconOpenoff.SetIcon(m_hIconOff);
        //delete []Device_pCirBuf;//删除数组pCirBuf指针对象,
        //Device_pCirBuf = NULL;//初始化为 空指针,
        Device_startPos=0;
        Device_endPos=0;
        return;
    }

8,退出按钮,设置缓冲区指针清零。

void CDevicedlg::OnClose()
{
    // TODO: Add your control notification handler code here
    //MessageBox(TEXT("是否确认删除?"),TEXT("Warning!!"),4);
    //AfxMessageBox("确定退出吗?","设备管理",MB_OKCANCEL)
    int ret=AfxMessageBox("确定退出吗?",MB_OKCANCEL);

    if(IDOK==ret)
    {
        //清除数据,避免bug。
        m_k6=0;
        m_k5=0;
        m_k4=0;
        m_k3=0;
        m_k2=0;
        m_k1=0;
        UpdateData(false);
        if(m_ctrlComm.GetPortOpen())
        {
            //             CByteArray m_Array;
            //             m_Array.RemoveAll();
            //             m_Array.SetSize(8);
            //             m_Array.SetAt(0,0xA5);
            //             m_Array.SetAt(1,0xA6);
            //             m_Array.SetAt(2,0x08);
            //             m_Array.SetAt(3,0xF5);  //钳子
            //             m_Array.SetAt(4,0xF6);  //线型
            //             m_Array.SetAt(5,0x0A);
            //             m_Array.SetAt(6,0x01);
            //             m_Array.SetAt(7,0xAD);
            //             m_ctrlComm.SetOutput(COleVariant(m_Array));

            m_ctrlComm.SetPortOpen(FALSE);
            if (Device_pCirBuf)
            {
                //delete []Device_pCirBuf;//删除数组pCirBuf指针对象
                //Device_pCirBuf = NULL;//初始化为空指针
                Device_startPos=0;
                Device_endPos=0;
            }

        }

        CDialog::OnOK();
    }
    else if(IDCANCEL==ret)
    {
        return;
    }
}

退出该对话框:

//退出软件
void CMyDlg::OnOK()
{
    // TODO: Add extra validation here
    //停止定时
    KillTimer(1);
    //关闭串口
    if(m_ctrlComm.GetPortOpen())
    {
        m_ctrlComm.SetPortOpen(FALSE);
        //缓冲区指针清零
        if (Device_pCirBuf)//可以吗,内存还有吗
        {
            Device_startPos=0;
            Device_endPos=0;
        }
    }
    CDialog::OnOK();
}

Normal
0

7.8 磅
0
2

false
false
false

EN-US
ZH-CN
X-NONE

MicrosoftInternetExplorer4

void
CDevicedlg::OnClose()

{

// TODO: Add your control notification
handler code here

//MessageBox(TEXT("是否确认删除?"),TEXT("Warning!!"),4);

//AfxMessageBox("确定退出吗?","设备管理",MB_OKCANCEL)

int ret=AfxMessageBox("确定退出吗?",MB_OKCANCEL);

if(IDOK==ret)

{

//清除数据,避免bug。

m_k6=0;

m_k5=0;

m_k4=0;

m_k3=0;

m_k2=0;

m_k1=0;

UpdateData(false);

if(m_ctrlComm.GetPortOpen())

{

//                       CByteArray
m_Array;

//                       m_Array.RemoveAll();

//                       m_Array.SetSize(8);

//                       m_Array.SetAt(0,0xA5);

//                       m_Array.SetAt(1,0xA6);

//                       m_Array.SetAt(2,0x08);

//                       m_Array.SetAt(3,0xF5);  //钳子

//                       m_Array.SetAt(4,0xF6);  //线型

//                       m_Array.SetAt(5,0x0A);

//                       m_Array.SetAt(6,0x01);

//                       m_Array.SetAt(7,0xAD);

//                       m_ctrlComm.SetOutput(COleVariant(m_Array));

m_ctrlComm.SetPortOpen(FALSE);

if
(Device_pCirBuf)

{

//delete
[]Device_pCirBuf;//删除数组pCirBuf指针对象

//Device_pCirBuf
= NULL;//初始化为空指针

Device_startPos=0;

Device_endPos=0;

}

}

CDialog::OnOK();

}

else if(IDCANCEL==ret)

{

return;

}

}

/* Style Definitions */
table.MsoNormalTable
{mso-style-name:普通表格;
mso-tstyle-rowband-size:0;
mso-tstyle-colband-size:0;
mso-style-noshow:yes;
mso-style-priority:99;
mso-style-qformat:yes;
mso-style-parent:"";
mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
mso-para-margin:0cm;
mso-para-margin-bottom:.0001pt;
mso-pagination:widow-orphan;
font-size:10.0pt;
font-family:"Times New Roman","serif";}

时间: 2024-10-05 00:54:02

vc6.0缓冲区的相关文章

如何在VC6.0里存储带空格的字符串

char str[20]; cin.getline(str,20) 或 string str; getline(cin,str); 据说都可以存储含空格字符串,但我用VC6.0时都出错 以下为粘贴 关于在C++中输入带空格的字符串的方法 yibcs 2012-08-10 20:44:17 此人文章 #include <iostream> #include <stdio.h>#include <string> using namespace std; void main(

VC6.0建立控制台程序

作者:iamlaosong 因为需要,又写起了文本界面的程序,以便PDA通过telnet连上执行.如果是Linux服务器的话,这是很简单的事,可是用户服务器是windows server 2003,所以就需要安装telnet服务,开发一个控制台程序.telnet服务器软件使用开源软件KpyM Telnet/SSH Server,控制台程序就用VC6.0来做了.网上搜了一下,通过下面链接操作即可: 怎么用VC6.0建立控制台程序 建议不要建立一个空程序,而是建立一个"Hello,World!&qu

(转)VC6.0中OpenGL开发环境配置

首先简单介绍一下OpenGL: OpenGL作为当前主流的图形API之一,它在一些场合具有比DirectX更优越的特性.       OpenGL官方网站(英文)    http://www.opengl.org 然后设置编程的一些环境,及其安装必备文件的步骤如下: 第一步:选择一个编译环境 现在Windows系统的主流编译环境有Visual Studio,Broland C++ Builder,Dev-C++等,它们都是支持OpenGL的.但这里我们选择VC++ 6.0作为学习OpenGL的环

VC6.0在Win10下的兼容性问题设置(可以试试)

Microsoft Visual C++ 6.0,简称VC6.0,是微软推出的一款C++编译器,将"高级语言"翻译为"机器语言(低级语言)"的程 序.Visual C++是一个功能强大的可视化软件开发工具.自1993年Microsoft公司推出Visual C++1.0后,随着其新版本的不断问 世,Visual C++已成为专业程序员进行软件开发的首选工具. VC++6.0主要是在Windows XP下运行,在win7,win8和win10下运行均会存在一些兼容性的

【转载】COM 组件设计与应用(九)——IDispatch 接口 for VC6.0

原文: http://vckbase.com/index.php/wv/1224.html 一.前言 终于写到了第九回,我也一直期盼着写这回的内容耶,为啥呢?因为自动化(automation)是非常常用.非常有用.非常精彩的一个 COM 功能.由于 WORD.EXCEL 等 OFFICE 软件提供了“宏”的功能,就连我们使用的VC开发环境也提供了“宏”功能,更由于 HTML.ASP.JSP 等都要依靠脚本(Script)的支持,更体现出了自动化接口的重要性. 如果你使用 vc6.0 的开发环境,

Visual C++ 6.0/VC6.0经典插件之源码窗口管理(Visual Booster )插件 安装图解

Visual Booster 是Visual C++ 6.0开发环境的辅助工具,使用该工具打开.cpp..h或者其他资源文件时会在左边及下边显示打开的窗口(并以后缀归类),查看源码的时候相当有用. 1.下载 Visual Booster  Visual Booster 下载地址:http://pan.baidu.com/s/1o6BTbV8 密码:vikq 2.安装 Visual Booster  下载之后解压文件,运行文件夹内的 "Visual Booster.exe" 进行安装.如

windows下vc6.0下的OpeSSL编译过程中的问题

我的机器环境是:window7 + vs2010 + vc6.0; 其实,在windows上用VS2010以上的工具来编译Openssl源码库很简单,估计大家都测试过,用VS2008及其以上的工具编译Openssl源码库就3行代码即可: perl Configure -WIN32 --prefix=d:/openssl ms\do_ms nmake -f ms\nt.mak vc6.0版本的openssl编译步骤如下: 1.打开命令提示符,找到vc6.0所在的bin目录,输入VCVARS32.B

关于VS2010帮助文档的使用和VC6.0在Win7 64位下的使用

由于购置了新的电脑,安装的是Win7 64位的操作系统,这两天我在重新安装编程环境的时候遇到一些问题,现在都解决掉了,分享出来以供需要的人参考. 一.以前使用的是VS2008,从VC6到2008这么多年了一只使用的MSDN是带索引的本地帮助,到了现在使用VS2010了,发现VS2010采用的是Web版形式的帮助. 并且也没有了索引.书签等非常的不习惯. 后来找到一个名字为:"h3viewer"的工具,在前提:已经安装了VS2010帮助文档的情况下.安装h3viewer,运行后界面如下:

vc6.0 PK vs2010

从VC++6.0不足看VisualC++2010新特性 说起VC,有人想到维生素C(维C),有人想到风险投资(venture capital), 程序员们尤其是做底层开发的程序员或老程序员们第一感觉肯定会想到Visual C++6.0.为什么是6.0而不是其它的版本?这里的原因就不用我再多讲了,因为太经典了!这个经典已经有了10年的光荣历史,微软的Visual Studio系列也已经发展到了Visual Studio 2010.漫长的辉煌中Visual C++6.0也暴露出了一些问题,在这篇文章