随笔-103  评论-224  文章-30  trackbacks-0
 
   原为某著名软件公司试题,大意如下:请实现以下两个函数:char toupper(char c); char tolower(char c); 分别用于将传入的字母转为大写和小写。两个函数传入的参数取值范围都是[a-zA-Z],并且为ASCII编码,实现时不用检查参数合法性。两个函数的实现不能使用任何形式的分支、跳转等类型的语句或指令(特别说明:C/C++的条件操作符?:也是分支指令的一种形式,故而不能使用)。请尽可能多的写出你知道的办法。   

  分析解决:此题比较特别,限制严格,根据题目要求,排除if else、for、while、do while、switch case、?:外,能使用的语句就只有 =、+=、-=、&、|、^、++、--这些了,想要实现大小写转换,只能从这些语句中进行选择思考,由于字符集为ASCII编码,且范围明确为[a-zA-Z],我们知道,a-z对应ASCII值为97-122,A-Z对应ASCII为65-90,观察这些数字,可以发现97-122都大于96 ,65-90都大于64且小于96,进一步从二进制上考虑,则发现所有小写字母对应的二进制形式为011XXXXX,大写字母对应的二进制形式为010XXXXX,一到这里,哈哈,答案就出来了,通过位运算&和|就可实现了。代码描述如下
 1 char toupper(char c)
 2 {
 3     return c & 0x5F;
 4 }

 5 
 6 char tolower(char c)
 7 {
 8     //c | 0x60也行,但不太好,因为0x60会改变结果的第7位值,根据题目意思,改变第6位值为1,而其它位保持不变就够了。
 9     return c | 0x20;
10}
   至于其它方法,我就没多想了,还希望各位大侠多多分享一下哈。
posted @ 2011-06-25 12:13 春秋十二月 阅读(3063) | 评论 (7)编辑 收藏
   原题为某游戏公司试题,大意如下:  对于一个单向链表,试写出找到它的倒序第m个元素(m >= 1)的函数,注意变量命名、注释、时间复杂度、空间复杂度。注:要求写出可编译并可以运行通过的程序代码。

  这道题的常规做法或者说首先想到直觉的方法M1是先求得链表的长度,即元素总个数n,然后问题转化为求顺序第n-m+1个元素。下面给出第2种方法M2:先求得顺序第m个元素,用一指针P指向这个元素,用另一指针PR指向链表的头部,现在好了,P和PR同时向右移动,直到P为空,则PR就是要求的倒序第m个元素,如果因m超越界限,则PR为空,表示没找到,这样一来,只需一次循环就够了。C++代码描述如下
 1 template<typename T>
 2 struct Node
 3 {  
 4     T  data;    /**////< 数据
 5     Node* next;  ///< 指向下一结点的指针
 6 } ;

 7 
 8 template<typename T>
 9 Node<T>* ReverseFind(Node<T>* head, size_t m)
10{
11    size_t  n = 0;
12    Node<T> *p, *pR = NULL;
13    for (p = head;p;p = p->next)
14    {
15        if (++== m)
16        {
17            pR = head;
18            continue;
19        }

20        if (pR)
21        {
22            pR = pR->next;
23        }

24    }

25    return pR;
26}
  现在分析这2种方法的时间复杂度,假设链表元素个数为N,所求倒序为第M元素,N>=M,则M1方法为0(N)+0(N-M)=0(2N-M),M2方法为O(M)+O(N-M)=0(N),因此M2快于M1。
posted @ 2011-06-24 11:40 春秋十二月 阅读(2395) | 评论 (11)编辑 收藏
   原题为某游戏公司的试题,大意如下:写一个千位分隔符算法,函数原型是 char * format_thousands_separator(unsigned long val); 要求实现效果是 1.使用者不需要释放返回的字符串指针 2.支持最多调用16次而不返回相同指针地址。可以用以下方法测试       
    printf("num1(%s), num2(%s), num3(%s)\n", format_thousands_separator(0),format_thousands_separator(123456),format_thousands_separator(23456789)); 
   注:要求写出可编译并可以运行通过的程序代码。

   经过修改后,我目前最简洁的C代码描述如下
 1 char* format_thousands_separator(unsigned long  val)
 2 {
 3     static char buf[16][16];
 4     static int  c = 0;
 5 
 6     long m, n = 0;
 7     char* p = &buf[c++ % 16][15];
 8     *= '\0';
 9 
10    do 
11    {
12        m = val % 10;
13        val = val / 10;
14        *--= '0' + m;
15
16        if (val && !(++% 3))
17            *--= ',';
18
19    }
 while(val);
20
21    return p;
22}
   这里再稍作一下扩展,使之能支持负数,代码描述如下
 1char* format_thousands_separator(long  val)
 2 {
 3     static char buf[16][16];
 4     static int  c = 0;
 5 
 6     long m, n = 0;
 7     char* p = &buf[c++ % 16][15];
 8     *= '\0';
 9 
10    do 
11    {
12        m = val % 10;
13        val = val / 10;
14        *--= '0' + (m < 0 ? -m : m);
15
16        if (!val && m < 0
17            *--= '-';
18
19        if (val && !(++% 3))
20            *--= ',';
21    
22    }
 while(val);
23
24    return p;
25}
   如果哪位大侠有更简洁高效的代码,还望留言或Email我,谢谢哈
posted @ 2011-06-24 10:55 春秋十二月 阅读(2736) | 评论 (4)编辑 收藏
     摘要:    一般地,泛型容器的设计实现大多只是存储了类型的单个对象,而没有存储类型的多个对象,如果有这样特定的需求,容器内的元素要求都是某个类型的多个对象,那么这时就可以考虑用模板类的数组特化来实现了,作为例程,下面C++代码描述了主模板实现 Code highlighting produced by Actipro CodeHighlighter (freewa...  阅读全文
posted @ 2011-06-23 12:01 春秋十二月 阅读(2368) | 评论 (2)编辑 收藏
   原为某软件公司试题,大意如下:对于给定的有符号32位整数,写一个函数,当该数为正数时返回1,为负数时返回-1,为零时返回零,要求不能使用任何的条件判断分支跳转语句。在这里,稍微扩展了一下,给出了对应无符号32位整数的情形。解决思路是符号位和值分开处理,对于有符号32位整数,符号位右移31位即得a,若为非负数则a=0x00000000,否则a=0xFFFFFFFF;然后将值部分各位的值(0或1不断缩小合并到一位中去得到b,这是针对0和正数的情况处理,再将a和b位即可。C++代码描述如下
 1//若val为0则返回0, val为负数则返回-1, 为正数返回1
 2int32_t check32(int32_t val)
 3{
 4    int32_t a = val >> 31;
 5    int32_t b = (val & 0x0000FFFF| ((val >> 16)&0x0000FFFF);
 6    b = (b & 0x000000FF| ((b >> 8)&0x000000FF);
 7    b = (b & 0x0000000F| ((b >> 4)&0x0000000F);
 8    b = (b & 0x00000003| ((b >> 2)&0x00000003);
 9    b = (b & 0x00000001| ((b >> 1)&0x00000001);
10   return a|b;
11}

12
13//若val为0则返回0, 否则返回1
14uint32_t check32(uint32_t val)
15{
16    uint32_t a = (val & 0x0000FFFF| ((val >> 16)&0x0000FFFF);
17    a = (a & 0x000000FF| ((a >> 8)&0x000000FF);
18    a = (a & 0x0000000F| ((a >> 4)&0x0000000F);
19    a = (a & 0x00000003| ((a >> 2)&0x00000003);
20    a = (a & 0x00000001| ((a >> 1)&0x00000001);
21    return a;
22}
   若哪位有更好的解法,还望多多分享
posted @ 2011-06-18 23:50 春秋十二月 阅读(3324) | 评论 (0)编辑 收藏
   WTL是窗口模板库(Windows Library Template)的简称,是一套轻量级C++ GUI库,因为它使用了C++模板封装了窗口界面操作API和消息映射处理,它扩展了ATL中的UI窗口部分,并支持如下更多的功能特性:
    (1)   对话框和通用控件:包括对话框数据交换(DDX),子类化,控件消息通知与反射等
    (2)   工具栏和状态栏:包括工具条UI状态更新,多窗格状态条及UI状态更新等
    (3)   分隔窗口:包括窗格容器,嵌套分隔,特殊绘制等
    (4)   属性页和向导:包括属性表,普通属性页,向导属性页等
    (5)   GDI类等:包括GDI封装类,通用对话框等
    (6)   使用ActiveX控件:包括使用控件类,调用控件的方法,控件事件映射处理等
    (7)   高级对话框UI类:包括自绘和外观定制类,新控件类,控件UI状态更新,对话框数据验证DDV等
    (8)   支持拖放操作:包括拖放接口实现类,最近使用文件列表等
   综上所述,使用WTL几乎可以实现MFC所能实现的功能与界面,而且生成的执行文件体积更小,不需要动态链接库就可直接快速地执行。

   根据WIN32窗口原理,当事件发生的时候,一般由父窗口接收其子窗口或控件的通知或命令消息,在这里父窗口是消息接收者,子窗口或控件是消息发送者,那么谁是消息处理者呢?实际上由谁来处理消息只是代码上的逻辑,既可以在父窗口的窗口过程回调内处理,也可以在子窗口或控件的窗口过程回调内处理,在哪处理更方便合理就在哪处理,如果是在子窗口或控件窗口过程回调内处理,那么就需要作额外的处理了,也就是在父窗口中将消息反射给发送者,进而再由发送者处理。下面以父窗口为打开文件对话框,双击它的列表视图控件为例,给出运用上面(1)中的控件消息通知与反射来处理NM_DBLCLK消息的两种实现方式。

   继承方式:由控件处理消息
   从CWindowImpl模板基类派生一个子窗口或控件子类即listview子类,添加消息映射项和消息处理函数,消息映射项用REFLECTED_NOTIFY_XXX或REFLECTED_COMMAND_XXX系列反射宏实现,具体使用哪个宏,决定于是否通知或命令消息,及消息对应的ID和通知码。
1class CFileListViewCtrl : public CWindowImpl<CFileListViewCtrl, CListViewCtrl>
2{
3 protected:
4      BEGIN_MSG_MAP(CFileListViewCtrl)
5          REFLECTED_NOTIFY_CODE_HANDLER_EX(NM_DBLCLK,OnListViewDblclk)   //反射通知消息处理宏
6          CHAIN_MSG_MAP(CListViewCtrl)
7     END_MSG_MAP()
8    LRESULT OnListViewDblclk(NMHDR* pNMHDR);   //消息响应处理函数
9}
;
   
   在父窗口类消息映射链中最后添加反射通知宏REFLECT_NOTIFICATIONS()项。                                           
 1class COpenFileDlg : public CDialogImpl<COpenFileDlg>  ,  public CWinDataExchange<COpenFileDlg>
 2{
 3public:
 4   COpenFileDlg();
 5   ~COpenFileDlg();
 6  enum  { IDD = IDD_OPEN_FILE_DLG };
 7
 8protected:
 9     BEGIN_MSG_MAP(COpenFileDlg)
10            MESSAGE_HANDLER(WM_INITDIALOG,OnInitDialog) 
11            REFLECT_NOTIFICATIONS()      //消息反射通知宏
12     END_MSG_MAP()
13    
14     BEGIN_DDX_MAP(COpenFileDlg)
15           DDX_CONTROL(IDC_LIST_FILE,m_list_File)
16     END_DDX_MAP()
17
18     LRESULT OnInitDialog(UINT uMsg,WPARAM wParam,LPARAM lParam,BOOL& bHandle);
19     
20private:
21    CFileListViewCtrl  m_list_File;    //使用派生类实例作为成员变量
22}
;

 成员方式:由父窗口处理消息 
   直接使用ATL中的包含窗口模板类CContainedWindowT,参数为子控件的类名即listviewctrl,实例化为父窗口类的一个成员变量,在父窗口类消息映射链中添加ALT_MSG_MAP宏来实现消息分派,其参数为分派ID,这个ID为成员变量初始化时指定的常量;添加反射通知宏REFLECT_NOTIFICATIONS(),注意ALT_MSG_MAP宏必须在反射通知宏REFLECT_NOTIFICATIONS之后。  
 1class COpenFileDlg : public CDialogImpl<COpenFileDlg> ,  public CWinDataExchange<COpenFileDlg>
 2{
 3    public:
 4        COpenFileDlg();
 5       ~COpenFileDlg();
 6  enum  { IDD = IDD_OPEN_FILE_DLG };
 7 
 8  protected:
 9     BEGIN_MSG_MAP(COpenFileDlg)
10          MESSAGE_HANDLER(WM_INITDIALOG,OnInitDialog) 
11          REFLECT_NOTIFICATIONS()           //  消息反射通知宏
12          ALT_MSG_MAP(1)                             //  消息分派宏
13          REFLECTED_NOTIFY_CODE_HANDLER_EX(NM_DBLCLK,OnListViewDblclk)     //  反射通知消息处理宏
14     END_MSG_MAP()
15
16     BEGIN_DDX_MAP(COpenFileDlg)
17           DDX_CONTROL(IDC_LIST_FILE,m_list_File)
18     END_DDX_MAP()
19
20     LRESULT OnInitDialog(UINT uMsg,WPARAM wParam,LPARAM lParam,BOOL& bHandle);
21     LRESULT OnListViewDblclk(NMHDR* pNMHDR);            //消息响应处理函数
22  private:
23    CContainedWindowT<CListViewCtrl>   m_list_File;    //  实例化包含窗口模板类作为成员变量
24 }
;

   在父窗口内需要初始化m_list_File以指定分派ID号。                                                               
1COpenFileDlg:: COpenFileDlg():
2m_list_File(this,1)     // 指定消息分派ID为1
3{  
4}
posted @ 2010-06-14 17:50 春秋十二月 阅读(5733) | 评论 (0)编辑 收藏

   MFC将windows消息系统进行了高度的抽象和封装,其根本原理是运用C++的高级特性并结合一定的设计模式(如工厂模式,模板方法等)来实现的。一般的windows消息(WM_XXX),则一定是由派生类流向基类,没有旁流的可能。如果是命令消息(WM_COMMAND),那就有比较奇特的路线了。下面就针对多文档/单文档(Document-View)、对话框两种应用程序比较讨论WM_COMMAND消息的传递处理过程。讨论前首先得明确命令消息的来源,命令消息一般是用户选择某个菜单项,或一个加速键被翻译,或一个子控件发送一个通知消息给它的父窗口时产生的。对一个菜单而言,消息接收者是Frame窗口或拥有它的对话框;对一个工具栏而言,消息接收者是它的父窗口。两种应用程序命令消息处理流程如下图所示。                   

   从上图可知,文档视图型的处理路线是先向下再向上,而对话框型的路线是一直向上,消息接收者只有一个,而处理者次序有多个,每个处理者内部首先都是调用根基类CCmdTarget的OnCmdMsg虚函数,在这个函数内逐级向基类遍历消息映射表,根据命令ID和通知码找到对应的消息映射结构体AFX_MSGMAP_ENTRY,如果找到再处理这个命令消息,否则返回FALSE,退回到this对象所在的OnCmdMsg函数进行下一步处理。如果到最后一层都没有找到对应命令的消息映射,则返回到系统的默认处理DefWindowProc。再综合考虑下,如果一个对话框接收到了一个命令消息例如是点击它的子控件工具栏某个按钮发出的,而这个对话框类没有添加相应的ON_COMMAND映射,就会进入到它的父窗口类OnCmdMsg函数进行处理,如果这个父窗口正好是Frame窗口,那么命令消息的处理流程就由上图右边转到左边了。而最终命令消息能否得处理,就看上图5种对象(Frame、View、Document、Dialog、App、Thread)是否添加了对应的ON_COMMAND映射。
   
   到此为止,我们已经明确了WM_COMMAND消息的处理流程,但是发现最终处理却是由收到消息的窗口传递的,不是消息通知者自己处理的,有的时候为了提高代码的封装性,可能需要自己处理这些命令比较方便,比如有一个工具栏CPlayToolBar子类从CToolBar继承,有播放、暂停、停止3个按钮,它的父窗口是CPlayDialog对话框。按照常规,这3个按钮命令事件的处理一般是在CPlayDialog类中3个ON_COMMAND映射宏和处理函数的,但如果在CPlayToolBar类中添加3个ON_COMMAND映射宏和处理函数,是得不到处理的,其原因在于对话框型的路线是一直向上,再者MFC中没有对应的命令反射ON_COMMAND_REFLECT这个宏。为了能使CPlayToolBar类自己处理这3个按钮命令事件,就需要从CPlayDialog类中转移路线,使之流向其子窗口工具栏,这样CPlayToolbar 类就得到了自己处理的机会。具体操作是重载CPlayToolBar和CPlayDialog的OnCommand虚函数,  CPlayDialog代码如下所示:
 1  BOOL   CPlayDialog::OnCommand(WPARAM wParam, LPARAM lParam)
 
2  {
 
3         if (lParam==(LPARAM)m_playtoolbar.m_hWnd)
 
4        {
 
5              m_playtoolbar.OnCommand(wParam,lParam);   //m_playtoolbar为CPlayToolBar对象,注意使OnCommand成为公有成员
 6        }

 
7       else
 
8       {
 
9            return   CDialog::OnCommand(wParam, lParam);
10       }

11   }
   CPlayToolBar类代码如下所示
 1    BEGIN_MESSAGE_MAP(CPlayToolBar, CToolBar)
 
2         ON_COMMAND(ID_PLAY,  Play)
 
3         ON_COMMAND(ID_PAUSE,  Pause)
 
4         ON_COMMAND(ID_STOP,  Stop)
 5    END_MESSAGE_MAP()
 
6
 7    void   CPlayToolBar::Play()
 
8    {
 
9    }

10   void   CPlayToolBar::Pause()
11   {
12   }

13   void   CPlayToolBar::Stop()
14   
15   }
    现在,3个按钮命令事件能在CPlayToolBar类中独立处理了,这样一来就提高了代码的封装性,简化了父窗口CPlayDialog类的处理。
posted @ 2009-12-19 21:29 春秋十二月 阅读(5827) | 评论 (1)编辑 收藏
   最近在工作中,写一计算杆塔绝缘子中心点的GPS坐标程序时,定义了一结构,里面用到了string类型来存储杆塔所属线路号、杆塔号,杆塔模型名称。代码如下:
 1/*
 2  @brief 杆塔信息结构
 3*/

 4typedef struct   _TOWER_INFO
 5{
 6       string    strLineNo;           ///< 线路号 
 7       string    strTowerNo;         ///< 杆塔号
 8       string    strTowerType;     ///< 杆塔类型
 9       double  dDangDistance;    ///< 档距
10      double  dHCHeight;           ///< 呼称高
11      double  dLongitude;          ///< 经度
12      double  dLatitude;              ///< 纬度
13      double  dAltitude;              ///< 海拔高度
14      double  dLineCorners;      ///< 线路转角 
15      long      lCornerDirection;  ///< 左转还是右转: 0不转, 1左转, 2右转
16      vector<INSULATOR_INFO::CENTER_POINT_INFO>  vecInsulatorCenterPointInfo; ///< 杆塔所有绝缘子中心点信息
17       _TOWER_INFO() { memset(this0sizeof(_TOWER_INFO)); }       //该行代码可能会引起string内存泄露
18
19}
TOWER_INFO,*PTOWER_INFO;
   在后面对该结构的string型变量有赋值操作, 代码如下
1   ......
2       TOWER_INFO cur_tower_center_info;
3   cur_tower_center_info.strLineNo = sheetLine->Cell(i, 2)->GetText(); //调度码
4   cur_tower_center_info.strTowerNo = sheetLine->Cell(i, 7)->GetText(); //杆塔号
5   cur_tower_center_info.strTowerType = sheetLine->Cell(i, 8)->GetText(); //杆塔类型
6      ......
   运行程序,待程序结束后,发现有内存泄露,提示信息如下
 1Detected memory leaks!
 2Dumping objects ->
 3{235250} normal block at 0x01774A6016 bytes long.
 4 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
 5{235237} normal block at 0x01774CB016 bytes long.
 6 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
 7{235234} normal block at 0x01774A1016 bytes long.
 8 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
 9{235184} normal block at 0x0177420016 bytes long.
10 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
11{235171} normal block at 0x0177445016 bytes long.
12 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
13{235168} normal block at 0x017741B016 bytes long.
14 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
15{235118} normal block at 0x017739A016 bytes long.
16 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
17{235105} normal block at 0x01773BF016 bytes long.
18 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
19..
   经过一番源代码跟踪调试后,发现原因在于TOWER_INFO结构体的构造函数内调用了memset(this, 0, sizeof(_TOWER_INFO);使得string内部指针_Bx._Ptrr值为0,_Myres为0,在这种情况下当string对象被赋值为小字符串(字节数包括结束符小于等于16的字符串)时,因新申请的内存在后来得不到释放,所以这块内存被泄露了,根据string类内存管理算法(ms vc版本)得知这块内存大小总是16个字节.但当被赋值为大字符串(字节数包括结束符大于16的字符串)时,反而没有内存泄露,这是因为新申请的内存在析构或下次赋值时总能被释放.
  从该泄露问题的分析解决过程中,总结得到规律:不要轻易零初始化string, vector等stl标准容器及具有动态内存管理的类。
posted @ 2009-08-07 01:31 春秋十二月 阅读(7073) | 评论 (19)编辑 收藏
   上次介绍了一种字符串转化为16进制显示的算法,并封装成了API,这个API可用于串口收到数据后按16进制显示字符串,这次介绍串口按16进制发送字符串的算法,使用基于字符类型参数的模板函数实现。算法原理是遍历字符串,将在区间'0'--'9','A'--'F','a'--'f'的字符转化成对应的16进制整数(范围为闭区间0-15),如遇到连续2个可以转换的字符,则将它们存储在一个无符号字节内,如遇到不能转化的字符,则略过继续。代码如下:
 1/**
 2    @brief 将字符转化为对应的10进制数整数 ASCII版本 
 3    * 若字符不能转化则返回-1
 4*/

 5template<typename charT>
 6inline char ConvertHexChar(charT ch)
 7{
 8    if(ch>=(charT)'0'&&ch<=(charT)'9')
 9        return ch-(charT)'0';
10    else if(ch>=(charT)'A'&&ch<=(charT)'F')
11        return ch-(charT)'A'+10;
12    else if(ch>=(charT)'a'&&ch<=(charT)'f')
13        return ch-(charT)'a'+10;
14    else 
15        return -1;
16}

17
18typedef std::vector<unsigned char> CByteArrayEx;
19
20/**
21    @brief 将字符串转化成对应的16进制数形式存储
22    @param template charT 源字符类型
23    @param src 源数据串
24    @param size 要转换的长度,字符数
25    @param ByteArray 存放结果的字节数组
26
27    * 如字符串80 12 34 46 AD FF,对应的就是0x80,0x12,0x34,0x46,0xAD,0xFF
28    该函数会自动过滤不能转换的字符,可转换字符范围在0--9,a--f,A--F区间   
29*/

30template<typename charT>
31inline void StrToHex(const charT* src,size_t len,CByteArrayEx& ByteArray)
32{
33    char low = -1, high = -1;
34    for (size_t n = 0; n < len; )
35    {
36        high = ConvertHexChar(src[n++]); 
37        if (-1 == high)
38        {
39            continue;
40        }

41        if (n >= len)
42        {
43            ByteArray.push_back(high);
44            break;
45        }

46        low = ConvertHexChar(src[n++]);
47        if (-1 == low)
48        {
49            ByteArray.push_back(high);
50            continue;
51        }

52        ByteArray.push_back(high * 16 + low);  
53    }

54}

55
56/**
57    @brief 将字符串转化成对应的16进制数形式存储
58    @param template charT 源字符类型
59    @param src 源数据串
60    @param ByteArray 存放结果的字节数组  
61*/

62template<typename charT>
63inline void StrToHex(const charT* src,CByteArrayEx& ByteArray)
64{
65    StrToHex(src,select_variable<is_ansi_char<s_charT>::value>(strlen,wcslen)(src),ByteArray);
66}
 
posted @ 2009-07-12 16:58 春秋十二月 阅读(2950) | 评论 (0)编辑 收藏
   最近在项目中调试串口,,总结封装了字符串转化为16进制显示的算法,串口数据发送一般为ASCII和16进制两种,当收到数据时数据也有ASCII和16进制显示两种方式,下面给出一种转化算法,该算法基于字符类型参数化的模板实现,字符串的转化只是调用其内存版本,算法原理是对字符串内存进行操作转化,以一个字节(unsigned char类型)为单位,分别取其高4位和低4位(范围为0x0--0xF), 转化为对应的目标字符('0'--'F')显示,代码如下
 1/**
 2    @brief MemToHex  
 3    @param template charT 字符类型
 4    @param src  源缓冲区
 5    @param size  lpSrc指向数据的大小,字节数
 6    @param tag  显示分隔符,默认为0表示空字符
 7    @return       返回转化后16进制字符串
 8*/

 9template<typename charT>
10inline std::basic_string<charT> MemToHex(const void* src, size_t size, bool upper = true,charT tag = 0)
11{
12    std::basic_string<charT> strDest;
13    strDest.reserve(2*size);
14    
15    unsigned char* pSrc = (unsigned char*)src;
16    unsigned char  buf[2];
17
18    for (size_t i = 0; i < size; ++i)
19    {
20        unsigned char c0 = *pSrc >> 4;  
21        if ( c0 >= 0x0 && c0 <= 0x9)
22            buf[0= c0 - 0 + '0';
23        else 
24            buf[0= c0 - 10 + (upper ? 'A' : 'a');
25        
26        unsigned char c1 = *pSrc++ & 0x0F;
27        if ( c1 >= 0x0 && c1 <= 0x9)
28            buf[1= c1 - 0 + '0';
29        else 
30            buf[1= c1 - 10 + (upper ? 'A' : 'a');
31        
32        strDest += (charT)buf[0];
33        strDest += (charT)buf[1];
34        if (tag != 0)  strDest += tag;
35    }

36    return strDest;
37}

38
39/**
40    @brief StrToHex 
41    @param template d_charT 目标字符类型
42    @param template s_charT 源字符类型
43    @param src  源字符串
44    @param upper  true表示大写,false表示小写
45    @param tag  显示分隔符,默认为0表示空字符
46    @return       返回转化后16进制字符串
47*/

48template<typename d_charT,typename s_charT>
49inline std::basic_string<d_charT> StrToHex(const s_charT* src, bool upper = true,d_charT tag = 0)
50{
51    return MemToHex(src,select_variable<is_ansi_char<s_charT>::value>(strlen,wcslen)(src)*sizeof(s_charT),upper,tag);
52}
   在应用中需要转化时, 只需调用StrToHex函数,示例如下:  
1    string strDest1 = StrToHex<char>("123456789汉字ABCXYZ");
2    wstring wstrDest1 = StrToHex<wchar_t>("123456789汉字ABCXYZ",true,' ');
3    string strDest2 = StrToHex<char>(L"123456789汉字ABCXYZ");
4    wstring wstrDest2 = StrToHex<wchar_t>(L"123456789汉字ABCXYZ"true,L',');
5
6    TRACE4("%s \n", strDest1.c_str());
7    TRACE4(L"%s \n", wstrDest1.c_str());
8    TRACE4("%s \n", strDest2.c_str());
9    TRACE4(L"%s \n", wstrDest2.c_str());
   结果输出如下:
1313233343536373839BABAD7D641424358595A 
231 32 33 34 35 36 37 38 39 BA BA D7 D6 41 42 43 58 59 5A  
3310032003300340035003600370038003900496C575B410042004300580059005A00 
431,00,32,00,33,00,34,00,35,00,36,00,37,00,38,00,39,00,49,6C,57,5B,41,00,42,00,43,00,58,00,59,00,5A,00
posted @ 2009-06-27 13:08 春秋十二月 阅读(12530) | 评论 (6)编辑 收藏
仅列出标题
共11页: First 3 4 5 6 7 8 9 10 11