在我的上一篇博客中（http://blog.csdn.net/liyuanbhu/article/details/51714045），介绍了通过 multimedia joystick API 来访问游戏手柄的基本方法。

最后说到了利用 joySetCapture 函数监听手柄事件的方式并不是非常的好用。建议大家字节写个监听线程，有针对性的监听需要的事件。这里，我把我以前写的一份代码放上来。代码是基于 Qt 的，监听了按键、摇杆和视觉头盔的状态，在状态发生改变时发出Qt 的信号。

按键对应两个信号：

  1. void Joy_ButtonPressed(int i);
  2. void Joy_ButtonReleased(int i);

摇杆分为两种模式：SWITCH_MODE 和 COORDINATE_MODE

SWITCH_MODE 模式下，输出四个方向的开关量。对应的信号是：

  1.     void Joy_MoveForward();
  2.     void Joy_MoveBackward();
  3.     void Joy_MoveForwardStop();
  4.     void Joy_MoveBackwardStop();
  5.     void Joy_MoveLeft();
  6.     void Joy_MoveRight();
  7.     void Joy_MoveLeftStop();
  8.     void Joy_MoveRightStop();

COORDINATE_MODE 模式直接输出坐标值（只有在摇杆位置发生变化时才会有输出）。

  1. void Joy_Position(int x, int y);

视觉头盔模拟了摇杆的开关量模式。对应的信号同样是：

  1.     void Joy_MoveForward();
  2.     void Joy_MoveBackward();
  3.     void Joy_MoveForwardStop();
  4.     void Joy_MoveBackwardStop();
  5.     void Joy_MoveLeft();
  6.     void Joy_MoveRight();
  7.     void Joy_MoveLeftStop();
  8.     void Joy_MoveRightStop();

具体的代码不用过多介绍，主要就是几个状态机。下面贴出代码来。

首先是头文件：

  1. #ifndef JOYSTICK_H
  2. #define JOYSTICK_H
  4. #include <QObject>
  5. #include <QThread>
  6. #include <Windows.h>
  7. #include <Mmsystem.h>
  9. class JoyStick;
  11. /**
  12.  * @brief The JoyStickThread class
  13.  * @details 内部类，定时轮询 JoyStick 的状态。
  14.  */
  15. class JoyStickThread : public QThread
  16. {
  17. public:
  18.     explicit JoyStickThread();
  19.     void setJoyStick(JoyStick *joystick);
  20.     void run();
  21.     void stop();
  22. private:
  23.     void Coordinate_StateMachine(int xPos, int yPos);
  24.     void AxisX_StateMachine(int xPos);
  25.     void AxisY_StateMachine(int yPos);
  26.     void Button_StateMachine(int button);
  27.     void POV_StateMachine_Axis(int pov);
  28.     void POV_StateMachine(int pov);
  29.     int old_xPos;
  30.     int old_yPos;
  31.     int old_pov;
  32.     bool pov_forward;
  33.     bool pov_backward;
  34.     bool pov_left;
  35.     bool pov_right;
  36.     bool pov_center;
  37.     int m_button[16];
  38.     JoyStick *m_joystick;
  39.     bool m_run;
  40. };
  42. class JoyStick : public QObject
  43. {
  44.     Q_OBJECT
  45. public:
  46.     enum MODE{SWITCH_MODE, COORDINATE_MODE};
  47.     /**
  48.      * @brief JoyStick
  49.      * @param mode SWITCH_MODE 模式时，摇杆输出开关量。COORDINATE_MODE 模式时，输出摇杆的位置。
  50.      * @param parent
  51.      */
  52.     explicit JoyStick(enum MODE mode = SWITCH_MODE, QObject *parent = 0);
  54.     enum MODE mode() const {return m_mode;}
  55.     ~JoyStick();
  56.     /**
  57.      * @brief listen
  58.      * @return 启动监听线程，之后就可以接收手柄的各种消息了。
  59.      */
  60.     bool listen();
  61.     /**
  62.      * @brief stop 停止监听线程，不需要接收手柄消息时可以调用这个函数。
  63.      */
  64.     void stop();
  65. signals:
  66.     /// JoyStick 的摇杆的各种信号。
  67.     /// 高级些的手柄是可以返回摇杆的坐标值的。
  68.     /// 这里模仿的是工业摇杆，输出的都是开关量。
  69.     /// 前后左右四组开关量。
  70.     void Joy_MoveForward();
  71.     void Joy_MoveBackward();
  72.     void Joy_MoveForwardStop();
  73.     void Joy_MoveBackwardStop();
  74.     void Joy_MoveLeft();
  75.     void Joy_MoveRight();
  76.     void Joy_MoveLeftStop();
  77.     void Joy_MoveRightStop();
  79.     /// JoyStick 的摇杆位置。
  80.     void Joy_Position(int x, int y);
  81.     /**
  82.      * @brief Joy_ButtonPressed 当手柄上某个按键被按下时发出这个信号
  83.      * @param i 用来标志是哪个按键被按下了。
  84.      */
  85.     void Joy_ButtonPressed(int i);
  86.     /**
  87.      * @brief Joy_ButtonReleased 当手柄上某个按键被释放时发出这个信号
  88.      * @param i 用来标志是哪个按键被释放了。
  89.      */
  90.     void Joy_ButtonReleased(int i);
  92.     /// 以下是视觉头盔的各种信号
  93.     void Joy_POVForward();
  94.     void Joy_POVBackward();
  95.     void Joy_POVLeft();
  96.     void Joy_POVRight();
  97.     void Joy_POVForwardLeft();
  98.     void Joy_POVForwardRight();
  99.     void Joy_POVBackwardLeft();
  100.     void Joy_POVBackwardRight();
  101.     /**
  102.      * @brief Joy_POVCentered 当视觉头盔从前8种状态恢复到默认状态时发出这个信号。
  103.      */
  104.     void Joy_POVCentered();
  106. private:
  107.     enum MODE m_mode;
  108.     bool m_valid;
  109.     JoyStickThread m_thread;
  110. };
  112. #endif // JOYSTICK_H

下面是cpp 文件：

  1. #include "joystick.h"
  2. #include <Windows.h>
  3. #include <QDebug>
  5. JoyStick::JoyStick(enum MODE mode, QObject *parent) : QObject(parent)
  6. {
  7.     m_mode = mode;
  8.     m_valid = false;
  9.     m_thread.setJoyStick(this);
  10.     JOYINFO joyinfo;
  11.     if( joyGetNumDevs() > 0 && joyGetPos(JOYSTICKID1, &joyinfo) != JOYERR_UNPLUGGED )
  12.     {
  13.         qDebug() << "JoyStick Init success!";
  14.         m_valid = true;
  15.     }
  16. }
  18. JoyStick::~JoyStick()
  19. {
  20.     m_thread.stop();
  21.     m_thread.wait();
  22. }
  24. bool JoyStick::listen()
  25. {
  26.     m_thread.start();
  27.     return true;
  28. }
  29. void JoyStick::stop()
  30. {
  31.     if(m_thread.isRunning())
  32.     {
  33.         m_thread.stop();
  34.         m_thread.wait();
  35.     }
  36. }
  38. JoyStickThread::JoyStickThread()
  39. {
  40.     m_run = 1;
  42.     old_xPos = 32767;
  43.     old_yPos = 32767;
  44.     for(int i = 0; i < 16; i++)
  45.     {
  46.         m_button[i] = 0;
  47.     }
  48.     old_pov = JOY_POVCENTERED;
  49.     pov_forward = false;
  50.     pov_backward = false;
  51.     pov_left = false;
  52.     pov_right = false;
  53.     pov_center = true;
  54. }
  56. void JoyStickThread::stop()
  57. {
  58.    m_run = 0;
  59. }
  61. void JoyStickThread::setJoyStick(JoyStick *joystick)
  62. {
  63.     m_joystick = joystick;
  64. }
  66. void JoyStickThread::run()
  67. {
  68.     //JOYINFO joyinfo;
  69.     JOYINFOEX joyinfoex;
  70.     joyinfoex.dwSize = sizeof(JOYINFOEX);
  71.     joyinfoex.dwFlags = JOY_RETURNALL;
  72.     while(m_run)
  73.     {
  74. //        if(joyGetPos(JOYSTICKID1, &joyinfo) == JOYERR_NOERROR)
  75. //        {
  76. //            //qDebug() << joyinfo.wXpos;
  77. //            AxisX_StateMachine(joyinfo.wXpos);
  78. //            AxisY_StateMachine(joyinfo.wYpos);
  79. //            Button_StateMachine(joyinfo.wButtons);
  80. //        }
  81.         if(joyGetPosEx(JOYSTICKID1, &joyinfoex) == JOYERR_NOERROR)
  82.         {
  83.             if(m_joystick->mode() == JoyStick::SWITCH_MODE)
  84.             {
  85.                 AxisX_StateMachine(joyinfoex.dwXpos);
  86.                 AxisY_StateMachine(joyinfoex.dwYpos);
  87.             }
  88.             else
  89.             {
  90.                 Coordinate_StateMachine(joyinfoex.dwXpos, joyinfoex.dwYpos);
  91.             }
  92.             Button_StateMachine(joyinfoex.dwButtons);
  93.             POV_StateMachine_Axis(joyinfoex.dwPOV);
  94.         }
  95.         msleep(50);
  96.     }
  97. }
  99. void JoyStickThread::POV_StateMachine(int pov)
  100. {
  101.     if(pov != old_pov)
  102.     {
  103.         //qDebug() << pov;
  104.         if( pov == JOY_POVFORWARD )
  105.         {
  106.             emit m_joystick->Joy_POVForward();
  107.         }
  108.         if( pov == JOY_POVFORWARD + 4500 )
  109.         {
  110.             emit m_joystick->Joy_POVForwardRight();
  111.         }
  112.         if( pov == JOY_POVRIGHT )
  113.         {
  114.             emit m_joystick->Joy_POVRight();
  115.         }
  116.         if( pov == JOY_POVRIGHT  + 4500 )
  117.         {
  118.             emit m_joystick->Joy_POVBackwardRight();
  119.         }
  120.         if( pov == JOY_POVBACKWARD )
  121.         {
  122.             emit m_joystick->Joy_POVBackward();
  123.         }
  124.         if( pov == JOY_POVBACKWARD + 4500 )
  125.         {
  126.             emit m_joystick->Joy_POVBackwardLeft();
  127.         }
  128.         if( pov == JOY_POVLEFT )
  129.         {
  130.             emit m_joystick->Joy_POVLeft();
  131.         }
  132.         if( pov == JOY_POVLEFT + 4500 )
  133.         {
  134.             emit m_joystick->Joy_POVForwardLeft();
  135.         }
  136.         if( pov == JOY_POVCENTERED )
  137.         {
  138.             emit m_joystick->Joy_POVCentered();
  139.         }
  140.         old_pov = pov;
  141.     }
  142. }
  144. void JoyStickThread::POV_StateMachine_Axis(int pov)
  145. {
  146.     if(pov != old_pov)
  147.     {
  148.         //qDebug() << pov;
  149.         if( pov == JOY_POVFORWARD )
  150.         {
  151.             if(pov_forward == false)
  152.             {
  153.                 pov_forward = true;
  154.                 emit m_joystick->Joy_MoveForward();
  155.                 //qDebug() << "JOY_POVFORWARD";
  156.             }
  157.             if(pov_left == true)
  158.             {
  159.                 emit m_joystick->Joy_MoveLeftStop();
  160.                 //qDebug() << "JOY_POVLEFT RETURN";
  161.             }
  162.             if(pov_right == true)
  163.             {
  164.                 emit m_joystick->Joy_MoveRightStop();
  165.                 //qDebug() << "JOY_POVRIGHT RETURN";
  166.             }
  167.             pov_left = false;
  168.             pov_right = false;
  169.         }
  170.         if( pov == JOY_POVFORWARD + 4500 )
  171.         {
  172.             if(pov_forward == false)
  173.             {
  174.                 pov_forward = true;
  175.                 emit m_joystick->Joy_MoveForward();
  176.                 //qDebug() << "JOY_POVFORWARD";
  177.             }
  178.             if(pov_right == false)
  179.             {
  180.                 pov_right = true;
  181.                 emit m_joystick->Joy_MoveRight();
  182.                 //qDebug() << "JOY_POVRIGHT";
  183.             }
  184.         }
  185.         if( pov == JOY_POVRIGHT )
  186.         {
  187.             if(pov_right == false)
  188.             {
  189.                 pov_right = true;
  190.                 emit m_joystick->Joy_MoveRight();
  191.                 //qDebug() << "JOY_POVRIGHT";
  192.             }
  193.             if(pov_forward == true)
  194.             {
  195.                 emit m_joystick->Joy_MoveForwardStop();
  196.                 //qDebug() << "JOY_POVFORWARD RETURN";
  197.             }
  198.             if(pov_backward == true)
  199.             {
  200.                 emit m_joystick->Joy_MoveBackwardStop();
  201.                 //qDebug() << "JOY_POVBACKWARD RETURN";
  202.             }
  203.             pov_forward = false;
  204.             pov_backward = false;
  205.         }
  206.         if( pov == JOY_POVRIGHT  + 4500 )
  207.         {
  208.             if(pov_right == false)
  209.             {
  210.                 pov_right = true;
  211.                 emit m_joystick->Joy_MoveRight();
  212.                // qDebug() << "JOY_POVRIGHT";
  213.             }
  214.             if(pov_backward == false)
  215.             {
  216.                 pov_backward = true;
  217.                 emit m_joystick->Joy_MoveBackward();
  218.                // qDebug() << "JOY_POVBACKWARD";
  219.             }
  220.         }
  221.         if( pov == JOY_POVBACKWARD )
  222.         {
  223.             if(pov_backward == false)
  224.             {
  225.                 pov_backward = true;
  226.                 emit m_joystick->Joy_MoveBackward();
  227.                 //qDebug() << "JOY_POVBACKWARD";
  228.             }
  229.             if(pov_left == true)
  230.             {
  231.                 emit m_joystick->Joy_MoveLeftStop();
  232.                 //qDebug() << "JOY_POVLEFT RETURN";
  233.             }
  234.             if(pov_right == true)
  235.             {
  236.                 emit m_joystick->Joy_MoveRightStop();
  237.                 //qDebug() << "JOY_POVRIGHT RETURN";
  238.             }
  239.             pov_left = false;
  240.             pov_right = false;
  241.         }
  242.         if( pov == JOY_POVBACKWARD + 4500 )
  243.         {
  244.             if(pov_backward == false)
  245.             {
  246.                 pov_backward = true;
  247.                 emit m_joystick->Joy_MoveBackward();
  248.                 //qDebug() << "JOY_POVBACKWARD";
  249.             }
  250.             if(pov_left == false)
  251.             {
  252.                 pov_left = true;
  253.                 emit m_joystick->Joy_MoveLeft();
  254.                // qDebug() << "JOY_POVLEFT";
  255.             }
  256.         }
  257.         if( pov == JOY_POVLEFT )
  258.         {
  259.             if(pov_left == false)
  260.             {
  261.                 pov_left = true;
  262.                 emit m_joystick->Joy_MoveLeft();
  263.                 //qDebug() << "JOY_POVLEFT";
  264.             }
  265.             if(pov_forward == true)
  266.             {
  267.                 emit m_joystick->Joy_MoveForwardStop();
  268.                 //qDebug() << "JOY_POVFORWARD RETURN";
  269.             }
  270.             if(pov_backward == true)
  271.             {
  272.                 emit m_joystick->Joy_MoveBackwardStop();
  273.                 //qDebug() << "JOY_POVBACKWARD RETURN";
  274.             }
  275.             pov_backward = false;
  276.             pov_forward = false;
  277.         }
  278.         if( pov == JOY_POVLEFT + 4500 )
  279.         {
  280.             if(pov_left == false)
  281.             {
  282.                 pov_left = true;
  283.                 emit m_joystick->Joy_MoveLeft();
  284.                 //qDebug() << "JOY_POVLEFT";
  285.             }
  286.             if(pov_forward == false)
  287.             {
  288.                 pov_forward = true;
  289.                 emit m_joystick->Joy_MoveForward();
  290.                 //qDebug() << "JOY_POVFORWARD";
  291.             }
  292.         }
  293.         if( pov == JOY_POVCENTERED )
  294.         {
  295.             if(pov_forward == true)
  296.             {
  297.                 emit m_joystick->Joy_MoveForwardStop();
  298.                 //qDebug() << "JOY_POVFORWARD RETURN";
  299.             }
  300.             if(pov_backward == true)
  301.             {
  302.                 emit m_joystick->Joy_MoveBackwardStop();
  303.                 //qDebug() << "JOY_POVBACKWARD RETURN";
  304.             }
  305.             if(pov_left == true)
  306.             {
  307.                 emit m_joystick->Joy_MoveLeftStop();
  308.                 //qDebug() << "JOY_POVLEFT RETURN";
  309.             }
  310.             if(pov_right == true)
  311.             {
  312.                 emit m_joystick->Joy_MoveRightStop();
  313.                 //qDebug() << "JOY_POVRIGHT RETURN";
  314.             }
  315.             pov_forward = false;
  316.             pov_right = false;
  317.             pov_left = false;
  318.             pov_backward = false;
  319.             //qDebug() << "JOY_POVCENTERED";
  320.         }
  321.         old_pov = pov;
  322.     }
  323. }
  325. void JoyStickThread::Button_StateMachine(int button)
  326. {
  327.     //if( button )
  328.     //qDebug() << QString::number(button, 16);
  329.     const int mask[16] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768};
  330.     for(int i = 0; i < 12; i++)
  331.     {
  332.         int n = button & mask[i];
  333.         if(n ^ m_button[i])
  334.         {
  335.             m_button[i] = n;
  336.             if( n )
  337.             {
  338.                 emit m_joystick->Joy_ButtonPressed(i + 1);
  339.                 //qDebug() << "ButtonPressed(" << i + 1 << ")";
  340.             }
  341.             else
  342.             {
  343.                 emit m_joystick->Joy_ButtonReleased(i + 1);
  344.                 //qDebug() << "ButtonReleased(" << i + 1 << ")";;
  345.             }
  346.         }
  347.     }
  348. }
  350. void JoyStickThread::Coordinate_StateMachine(int xPos, int yPos)
  351. {
  352.     if(xPos == old_xPos && yPos == old_yPos)
  353.     {
  354.         return;
  355.     }
  356.     old_xPos = xPos;
  357.     old_yPos = yPos;
  358.     emit m_joystick->Joy_Position(xPos, yPos);
  359. }
  361. void JoyStickThread::AxisX_StateMachine(int xPos)
  362. {
  363.     if(xPos == old_xPos) return;
  364.     switch(xPos)
  365.     {
  366.     case 0:
  367.         emit m_joystick->Joy_MoveLeft();
  368.         break;
  369.     case 32767:
  370.         if(old_xPos == 0)
  371.         {
  372.             emit m_joystick->Joy_MoveLeftStop();
  373.         }
  374.         else
  375.         {
  376.             emit m_joystick->Joy_MoveRightStop();
  377.         }
  378.         break;
  379.     case 65535:
  380.         emit m_joystick->Joy_MoveRight();
  381.         break;
  382.     }
  383.     old_xPos = xPos;
  384. }
  386. void JoyStickThread::AxisY_StateMachine(int yPos)
  387. {
  388.     if(yPos == old_yPos) return;
  389.     switch(yPos)
  390.     {
  391.     case 0:
  392.         emit m_joystick->Joy_MoveForward();
  393.         break;
  394.     case 32767:
  395.         if(old_xPos == 0)
  396.         {
  397.             emit m_joystick->Joy_MoveForwardStop();
  398.         }
  399.         else
  400.         {
  401.             emit m_joystick->Joy_MoveBackwardStop();
  402.         }
  403.         break;
  404.     case 65535:
  405.         emit m_joystick->Joy_MoveBackward();
  406.         break;
  407.     }
  408.     old_yPos = yPos;
  409. }

具体的使用方法很简答，建立对象后，只要调用 listen() 函数开始监听就可以了。

当然在监听之前，还要连接好需要的信号和槽。

游戏手柄（JoyStick）编程学习笔记（2）的更多相关文章

  1. JAVA GUI编程学习笔记目录

    2014年暑假JAVA GUI编程学习笔记目录 1.JAVA之GUI编程概述 2.JAVA之GUI编程布局 3.JAVA之GUI编程Frame窗口 4.JAVA之GUI编程事件监听机制 5.JAVA之 ...

  2. Linux Shell编程学习笔记——目录（附笔记资源下载)

    LinuxShell编程学习笔记目录附笔记资源下载 目录(?)[-] 写在前面 第一部分 Shell基础编程 第二部分 Linux Shell高级编程技巧 资源下载 写在前面 最近花了些时间学习She ...

  3. DirectX 11游戏编程学习笔记之8: 第6章Drawing in Direct3D(在Direct3D中绘制)(习题解答)

            本文由哈利_蜘蛛侠原创,转载请注明出处.有问题欢迎联系2024958085@qq.com         注:我给的电子版是700多页,而实体书是800多页,所以我在提到相关概念的时候 ...

  4. 多线程编程学习笔记——async和await（一）

    接上文 多线程编程学习笔记——任务并行库(一) 接上文 多线程编程学习笔记——任务并行库(二) 接上文 多线程编程学习笔记——任务并行库(三) 接上文 多线程编程学习笔记——任务并行库(四) 通过前面 ...

  5. 多线程编程学习笔记——async和await（二）

    接上文 多线程编程学习笔记——async和await(一) 三.   对连续的异步任务使用await操作符 本示例学习如何阅读有多个await方法方法时,程序的实际流程是怎么样的,理解await的异步 ...

  6. 多线程编程学习笔记——async和await（三）

    接上文 多线程编程学习笔记——async和await(一) 接上文 多线程编程学习笔记——async和await(二) 五.   处理异步操作中的异常 本示例学习如何在异步函数中处理异常,学习如何对多 ...

  7. 多线程编程学习笔记——使用异步IO（一）

    接上文 多线程编程学习笔记——使用并发集合(一) 接上文 多线程编程学习笔记——使用并发集合(二) 接上文 多线程编程学习笔记——使用并发集合(三) 假设以下场景,如果在客户端运行程序,最的事情之一是 ...

  8. 多线程编程学习笔记——编写一个异步的HTTP服务器和客户端

    接上文 多线程编程学习笔记——使用异步IO 二.   编写一个异步的HTTP服务器和客户端 本节展示了如何编写一个简单的异步HTTP服务器. 1.程序代码如下. using System; using ...

  9. 多线程编程学习笔记——异步调用WCF服务

    接上文 多线程编程学习笔记——使用异步IO 接上文 多线程编程学习笔记——编写一个异步的HTTP服务器和客户端 接上文 多线程编程学习笔记——异步操作数据库 本示例描述了如何创建一个WCF服务,并宿主 ...

  10. 【Visual C++】游戏编程学习笔记之四：透明动画实现

    本系列文章由@二货梦想家张程 所写,转载请注明出处. 本文章链接:http://blog.csdn.net/terence1212/article/details/44224963 作者:ZeeCod ...

随机推荐

  1. ArrayBlockingQueue 阻塞队列和 Semaphore 信号灯的应用

    import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public cl ...

  2. c# 托管和非托管的介绍

    在.net 编程环境中,系统的资源分为托管资源和非托管资源. 对于托管的资源的回收工作,是不需要人工干预回收的,而且你也无法干预他们的回收,所能够做的 只是了解.net CLR如何做这些操作.也就是说 ...

  3. 如何让触摸事件穿透一个View

    如何让触摸事件穿透一个View 偶然间发现,如何屏蔽或者让触摸事件穿透一个view是一个很简单的事情. 现象: 源码: // // ViewController.m // UserInteractio ...

  4. UNIX高级环境编程（1）File I/O

    引言: Unix系统中主要的文件操作包括: open read write lseek close unbuffered IO和standard I/O相对应,后面的章节我们会讨论这两者的区别. 在讨 ...

  5. Elasticsearch部分节点不能发现集群(脑裂)问题处理

    **现象描述** es1,es2,es3三台es组成一个集群,集群状态正常, 当es1 服务器重启后,es1不能加到集群中,自己选举自己为master,这就产生了es集群中所谓的“脑裂” , 把es1 ...

  6. Linux blkid命令详解

    blkid命令对查询设备上所采用文件系统类型进行查询.blkid主要用来对系统的块设备(包括交换分区)所使用的文件系统类型.LABEL.UUID等信息进行查询.要使用这个命令必须安装e2fsprogs ...

  7. CSS学习摘要-浮动与清除浮动

    以下从浮动到BFC的段落 摘自MDN 网络开发者 float 浮动 float CSS属性指定一个元素应沿其容器的左侧或右侧放置,允许文本和内联元素环绕它.该元素从网页的正常流动中移除,尽管仍然保持部 ...

  8. Test checkout of feature 'Compiler' failed 解决方法(转载)

    Test checkout of feature 'Compiler' failed.   2014a的解决办法 适用于已安装compiler但破解不完全的, ht—tp://pan.baidu.co ...

  9. September 19th 2017 Week 38th Tuesday

    Live boldly. Push yourself. Don't settle. 勇敢生活,突破自我,永不设限! Don't indulge in the past, whether it was ...

  10. [EffectiveC++]item28：避免返回handles指向对象内部成分

    可以先参考一个帖子:http://bbs.csdn.net/topics/390731394?page=1