设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › QrcodeVC二维码生成VC源代码
返回列表 发新帖
查看: 8934|回复: 11
打印 上一主题 下一主题
收起左侧

QrcodeVC二维码生成VC源代码

  [复制链接]
跳转到指定楼层
楼主
ID:113178 发表于 2016-4-9 21:44 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
QrcodeVC二维码生成VC源代码.rar (1014.98 KB, 下载次数: 79)

部分程序预览：
  1. // Qrcode.cpp: implementation of the Qrcode class.
  2. //
  3. //////////////////////////////////////////////////////////////////////

  5. #include "stdafx.h"
  6. #include "QrcodeApp.h"
  7. #include "Qrcode.h"
  8. #include <math.h>

  10. #ifdef _DEBUG
  11. #undef THIS_FILE
  12. static char THIS_FILE[]=__FILE__;
  13. #define new DEBUG_NEW
  14. #endif
  15. #define QRCODE_DATA_PATH  "qrcode_data"
  16. //////////////////////////////////////////////////////////////////////
  17. // Construction/Destruction
  18. //////////////////////////////////////////////////////////////////////

  20. Qrcode::Qrcode()
  21. {       
  22.         qrcodeErrorCorrect = 'M';
  23.         qrcodeEncodeMode = 'B';
  24.         qrcodeVersion = 0;
  25.         qrcodeStructureappendN = 0;
  26.         qrcodeStructureappendM = 0;
  27.         qrcodeStructureappendParity = 0;
  28.         qrcodeStructureappendOriginaldata = "";       
  29. }

  31. Qrcode::~Qrcode()
  32. {
  33.        
  34. }

  36. void Qrcode::setQrcodeErrorCorrect(char c)
  37. {
  38.         qrcodeErrorCorrect = c;
  39. }

  41. char Qrcode::getQrcodeErrorCorrect()
  42. {
  43.         return qrcodeErrorCorrect;
  44. }

  46. int Qrcode::getQrcodeVersion()
  47. {
  48.         return qrcodeVersion;
  49. }

  51. void Qrcode::setQrcodeVersion(int i)
  52. {
  53.         if(i >= 0 && i <= 40)
  54.                 qrcodeVersion = i;
  55. }

  57. void Qrcode::setQrcodeEncodeMode(char c)
  58. {
  59.         qrcodeEncodeMode = c;
  60. }

  62. char Qrcode::getQrcodeEncodeMode()
  63. {
  64.         return qrcodeEncodeMode;
  65. }

  67. void Qrcode::setStructureappend(int i, int j, int k)
  68. {
  69.         if(j > 1 && j <= 16 && i > 0 && i <= 16 && k >= 0 && k <= 255)
  70.         {
  71.                 qrcodeStructureappendM = i;
  72.                 qrcodeStructureappendN = j;
  73.                 qrcodeStructureappendParity = k;
  74.         }
  75. }

  77. //int Qrcode::calStructureappendParity(char abyte0[],int i)
  78. int Qrcode::calStructureappendParity(char* abyte0,int i)
  79. {
  80.         int j = 0;
  81.         int k = 0;
  82.         //int i = abyte0.length;
  83.         if(i > 1)
  84.         {
  85.                 k = 0;
  86.                 for(; j < i; j++)
  87.                         k ^= abyte0[j] & 255;
  88.                
  89.         } else
  90.         {
  91.                 k = -1;
  92.         }
  93.         return k;
  94. }

  96. //bool** Qrcode::calQrcode(char abyte0[],int iLen0,int& iLenRet)
  97. bool** Qrcode::calQrcode(char* abyte0,int iLen0,int& iLenRet)
  98. {
  99.         int j = 0;
  100.         int n1;
  101.         int i = iLen0;
  102.         //int ai[] = new int[i + 32];
  103.         int* ai = new int[i + 32];
  104.         //char abyte1[] = new char[i + 32];
  105.         char* abyte1 = new char[i + 32];
  106.         memset(abyte1,0,i+32);
  107.         if(i <= 0)
  108.         {               
  109.                 bool** aflag=new bool*[1];
  110.                 aflag[0]=new bool[1];
  111.                 aflag[0][0]=false;
  112.                 iLenRet=1;
  113.                 return aflag;
  114.         }
  115.         if(qrcodeStructureappendN > 1)
  116.         {
  117.                 ai[0] = 3;
  118.                 abyte1[0] = 4;
  119.                 ai[1] = qrcodeStructureappendM - 1;
  120.                 abyte1[1] = 4;
  121.                 ai[2] = qrcodeStructureappendN - 1;
  122.                 abyte1[2] = 4;
  123.                 ai[3] = qrcodeStructureappendParity;
  124.                 abyte1[3] = 8;
  125.                 j = 4;
  126.         }
  127.         abyte1[j] = 4;
  128.         //int* ai1=new int[41];
  129.         int ai1[41];
  130.         int k;
  131.         switch(qrcodeEncodeMode)
  132.         {
  133.         case 65: // 'A'
  134.                          /*ai1 = (new int[] {
  135.                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  136.                          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  137.                          2, 2, 2, 2, 2, 2, 2, 4, 4, 4,
  138.                          4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  139.                          4
  140.         });*/
  141.                 {
  142.                         for(int ii=0;ii<41;ii++)
  143.                         {
  144.                                 if(ii<=9)ai1[ii]=0;
  145.                                 else if(ii<=26)ai1[ii]=2;
  146.                                 else ai1[ii]=4;
  147.                         }
  148.                        
  149.                         ai[j] = 2;
  150.                         j++;
  151.                         ai[j] = i;
  152.                         abyte1[j] = 9;
  153.                         k = j;
  154.                         j++;
  155.                         for(int l = 0; l < i; l++)
  156.                         {
  157.                                 char c = (char)abyte0[l];
  158.                                 char byte0 = 0;
  159.                                 if(c >= '0' && c < ':')
  160.                                         byte0 = (char)(c - 48);
  161.                                 else
  162.                                         if(c >= 'A' && c < '[')
  163.                                         {
  164.                                                 byte0 = (char)(c - 55);
  165.                                         } else
  166.                                         {
  167.                                                 if(c == ' ')
  168.                                                         byte0 = 36;
  169.                                                 if(c == '

  171. )
  172.                                                         byte0 = 37;
  173.                                                 if(c == '%')
  174.                                                         byte0 = 38;
  175.                                                 if(c == '*')
  176.                                                         byte0 = 39;
  177.                                                 if(c == '+')
  178.                                                         byte0 = 40;
  179.                                                 if(c == '-')
  180.                                                         byte0 = 41;
  181.                                                 if(c == '.')
  182.                                                         byte0 = 42;
  183.                                                 if(c == '/')
  184.                                                         byte0 = 43;
  185.                                                 if(c == ':')
  186.                                                         byte0 = 44;
  187.                                         }
  188.                                         if(l % 2 == 0)
  189.                                         {
  190.                                                 ai[j] = byte0;
  191.                                                 abyte1[j] = 6;
  192.                                         } else
  193.                                         {
  194.                                                 ai[j] = ai[j] * 45 + byte0;
  195.                                                 abyte1[j] = 11;
  196.                                                 if(l < i - 1)
  197.                                                         j++;
  198.                                         }
  199.                         }                       
  200.                         j++;                       
  201.                 }               
  202.                 break;               
  203.         case 78: // 'N'
  204.                          /*ai1 = (new int[] {
  205.                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  206.                          2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  207.                          2, 2, 2, 2, 2, 2, 2, 4, 4, 4,
  208.                          4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  209.                          4
  210.         });*/
  211.                 {
  212.                         for(int ii=0;ii<41;ii++)
  213.                         {
  214.                                 if(ii<=9)ai1[ii]=0;
  215.                                 else if(ii<=26)ai1[ii]=2;
  216.                                 else ai1[ii]=4;
  217.                         }
  218.                         ai[j] = 1;
  219.                         j++;
  220.                         ai[j] = i;
  221.                         abyte1[j] = 10;
  222.                         k = j;
  223.                         j++;
  224.                         for(int i1 = 0; i1 < i; i1++)
  225.                                 if(i1 % 3 == 0)
  226.                                 {
  227.                                         ai[j] = abyte0[i1] - 48;
  228.                                         abyte1[j] = 4;
  229.                                 } else
  230.                                 {
  231.                                         ai[j] = ai[j] * 10 + (abyte0[i1] - 48);
  232.                                         if(i1 % 3 == 1)
  233.                                         {
  234.                                                 abyte1[j] = 7;
  235.                                         } else
  236.                                         {
  237.                                                 abyte1[j] = 10;
  238.                                                 if(i1 < i - 1)
  239.                                                         j++;
  240.                                         }
  241.                                 }
  242.                                
  243.                                 j++;
  244.                                
  245.                 }               
  246.                 break;                       
  247.         default:
  248.         /*ai1 = (new int[] {
  249.                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  250.                 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  251.                 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  252.                 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  253.                 8
  254.                 });*/               
  255.                 for(int ii=0;ii<41;ii++)
  256.                 {
  257.                         if(ii<=9)ai1[ii]=0;                       
  258.                         else ai1[ii]=8;
  259.                 }
  260.                 ai[j] = 4;
  261.                 j++;
  262.                 ai[j] = i;
  263.                 abyte1[j] = 8;
  264.                 k = j;
  265.                 j++;
  266.                 for(int j1 = 0; j1 < i; j1++)
  267.                 {
  268.                         ai[j1 + j] = abyte0[j1] & 255;
  269.                         abyte1[j1 + j] = 8;
  270.                 }
  271.                
  272.                 j += i;
  273.                 break;
  274.         }
  275.         int k1 = 0;
  276.         for(int l1 = 0; l1 < j; l1++)
  277.             k1 += abyte1[l1];
  278.                
  279.         char byte1;
  280.         switch(qrcodeErrorCorrect)
  281.         {
  282.         case 76: // 'L'
  283.             byte1 = 1;
  284.             break;
  285.                        
  286.         case 81: // 'Q'
  287.             byte1 = 3;
  288.             break;
  289.                        
  290.         case 72: // 'H'
  291.             byte1 = 2;
  292.             break;
  293.                        
  294.         default:
  295.             byte1 = 0;
  296.             break;
  297.         }

  299.         //int ai2[4][41] = {
  300.                 int ai2[4][41] = {
  301.             {
  302.                                         0, 128, 224, 352, 512, 688, 864, 992, 1232, 1456,
  303.                                         1728, 2032, 2320, 2672, 2920, 3320, 3624, 4056, 4504, 5016,
  304.                                         5352, 5712, 6256, 6880, 7312, 8000, 8496, 9024, 9544, 10136,
  305.                                         10984, 11640, 12328, 13048, 13800, 14496, 15312, 15936, 16816, 17728,
  306.                                         18672
  307.             },
  308.                         {
  309.                                         0, 152, 272, 440, 640, 864, 1088, 1248, 1552, 1856,
  310.                                         2192, 2592, 2960, 3424, 3688, 4184, 4712, 5176, 5768, 6360,
  311.                                         6888, 7456, 8048, 8752, 9392, 10208, 10960, 11744, 12248, 13048,
  312.                                         13880, 14744, 15640, 16568, 17528, 18448, 19472, 20528, 21616, 22496,
  313.                                         23648
  314.                                 },
  315.                                 {
  316.                                                 0, 72, 128, 208, 288, 368, 480, 528, 688, 800,
  317.                                                         976, 1120, 1264, 1440, 1576, 1784, 2024, 2264, 2504, 2728,
  318.                                                         3080, 3248, 3536, 3712, 4112, 4304, 4768, 5024, 5288, 5608,
  319.                                                         5960, 6344, 6760, 7208, 7688, 7888, 8432, 8768, 9136, 9776,
  320.                                                         10208
  321.                                         },
  322.                                         {
  323.                                                         0, 104, 176, 272, 384, 496, 608, 704, 880, 1056,
  324.                                                                 1232, 1440, 1648, 1952, 2088, 2360, 2600, 2936, 3176, 3560,
  325.                                                                 3880, 4096, 4544, 4912, 5312, 5744, 6032, 6464, 6968, 7288,
  326.                                                                 7880, 8264, 8920, 9368, 9848, 10288, 10832, 11408, 12016, 12656,
  327.                                                                 13328
  328.                                                 }
  329.         };
  330.         int i2 = 0;
  331.         if(qrcodeVersion == 0)
  332.         {
  333.             qrcodeVersion = 1;
  334.             for(int j2 = 1; j2 <= 40; j2++)
  335.             {
  336.                 if(ai2[byte1][j2] >= k1 + ai1[qrcodeVersion])
  337.                 {
  338.                     i2 = ai2[byte1][j2];
  339.                     break;
  340.                 }
  341.                 qrcodeVersion++;
  342.             }
  343.                        
  344.         } else
  345.         {
  346.             i2 = ai2[byte1][qrcodeVersion];
  347.         }
  348.         k1 += ai1[qrcodeVersion];
  349.         abyte1[k] += ai1[qrcodeVersion];
  350.         int ai3[] = {
  351.             0, 26, 44, 70, 100, 134, 172, 196, 242, 292,
  352.                                 346, 404, 466, 532, 581, 655, 733, 815, 901, 991,
  353.                                 1085, 1156, 1258, 1364, 1474, 1588, 1706, 1828, 1921, 2051,
  354.                                 2185, 2323, 2465, 2611, 2761, 2876, 3034, 3196, 3362, 3532,
  355.                                 3706
  356.         };
  357.         int k2 = ai3[qrcodeVersion];
  358.         int l2 = 17 + (qrcodeVersion << 2);
  359.         int ai4[] = {
  360.             0, 0, 7, 7, 7, 7, 7, 0, 0, 0,
  361.                                 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
  362.                                 3, 4, 4, 4, 4, 4, 4, 4, 3, 3,
  363.                                 3, 3, 3, 3, 3, 0, 0, 0, 0, 0,
  364.                                 0
  365.         };
  366.         int i3 = ai4[qrcodeVersion] + (k2 << 3);
  367.         char* abyte2 = new char[i3];
  368.         char* abyte3 = new char[i3];
  369.         char* abyte4 = new char[i3];               
  370.                 char abyte5[15];
  371.                 char abyte6[15];
  372.                 char abyte7[1];
  373.                 char abyte8[128];
  374.                
  375.                 memset(abyte2,0,i3);
  376.                 memset(abyte3,0,i3);
  377.                 memset(abyte4,0,i3);
  378.                 memset(abyte5,0,15);
  379.                 memset(abyte6,0,15);
  380.                 memset(abyte7,0,1);
  381.                 memset(abyte8,0,128);
  382.                
  383.         try
  384.         {
  385.             //CString s = "qrcode_data/qrv" + Integer.toString(qrcodeVersion) + "_" + Integer.toString(byte1) + ".dat";
  386.                         CString s;
  387.                         s.Format("qrcode_data/qrv%d_%d.dat",qrcodeVersion,byte1);                       
  388.                        
  389.                         //CFile f(s, CFile::modeCreate | CFile::modeWrite );       
  390.                         CFile f(s, CFile::modeRead);
  391.                         try
  392.                         {                               
  393.                                 f.Read(abyte2, i3);
  394.                                 f.Read(abyte3, i3);
  395.                                 f.Read(abyte4, i3);
  396.                                 f.Read(abyte5, 15);
  397.                                 f.Read(abyte6, 15);
  398.                                 f.Read(abyte7, 1);
  399.                                 f.Read(abyte8, 128);
  400.                                 f.Close();
  401.                        
  402.                         }
  403.                         catch(...)
  404.                         {                       
  405.                                 f.Close();
  406.                         }
  407.                        
  408.                         //写临时文件
  409.             /*InputStream inputstream = (com.swetake.util.Qrcode.class).getResourceAsStream(s);
  410.             BufferedInputStream bufferedinputstream = new BufferedInputStream(inputstream);
  411.             bufferedinputstream.read(abyte2);
  412.             bufferedinputstream.read(abyte3);
  413.             bufferedinputstream.read(abyte4);
  414.             bufferedinputstream.read(abyte5);
  415.             bufferedinputstream.read(abyte6);
  416.             bufferedinputstream.read(abyte7);
  417.             bufferedinputstream.read(abyte8);
  418.             bufferedinputstream.close();
  419.             inputstream.close();*/
  420.         }
  421.         catch(CException exception)
  422.         {
  423.                         //AfxMessageBox(exception.)
  424.             //exception.printStackTrace();
  425.         }
  426.         int j3 = 1;
  427.         for(char byte2 = 1; byte2 < 128; byte2++)
  428.         {
  429.             if(abyte8[byte2] != 0)
  430.                 continue;
  431.             j3 = byte2;
  432.             break;
  433.         }
  434.                
  435.         char* abyte9 = new char[j3+1];
  436.                 memset(abyte9,0,j3);
  437.                 memcpy(abyte9,abyte8,j3);
  438.                 abyte9[j3]=0;
  439.         //System.arraycopy(abyte8, 0, abyte9, 0, j3);
  440.         char abyte10[15] = {
  441.                         0, 1, 2, 3, 4, 5, 7, 8, 8, 8,
  442.                                 8, 8, 8, 8, 8
  443.         };
  444.         char abyte11[15] = {
  445.                         8, 8, 8, 8, 8, 8, 8, 8, 7, 5,
  446.                                 4, 3, 2, 1, 0
  447.         };
  448.         int k3 = i2 >> 3;
  449.         int l3 = 4 * qrcodeVersion + 17;
  450.         int i4 = l3 * l3;
  451.         char* abyte12 = new char[i4 + l3];
  452.                 memset(abyte12,0,i4 + l3);
  453.         try
  454.         {
  455.             //CString s1 = "qrcode_data/qrvfr" + Integer.toString(qrcodeVersion) + ".dat";
  456.                         CString s1;
  457.                         s1.Format("qrcode_data/qrvfr%d.dat",qrcodeVersion);
  458.                         //CFile f1(s1, CFile::modeCreate | CFile::modeWrite );       
  459.                         CFile f1(s1, CFile::modeRead);
  460.                         try
  461.                         {                               
  462.                                 f1.Read(abyte12, i4 + l3);
  463.                                 f1.Close();
  464.                         }
  465.                         catch(...)
  466.                         {                       
  467.                                 f1.Close();
  468.                         }         
  469.         }
  470.         catch(CException exception1)
  471.         {
  472.                         // exception1.printStackTrace();
  473.         }
  474.         if(k1 <= i2 - 4)
  475.         {
  476.             ai[j] = 0;
  477.             abyte1[j] = 4;
  478.         } else
  479.                         if(k1 < i2)
  480.                         {
  481.                                 ai[j] = 0;
  482.                                 abyte1[j] = (char)(i2 - k1);
  483.                         } else
  484.                                 if(k1 > i2)
  485.                                         TRACE("overflow");
  486.                                 //AfxMessageBox()
  487.                                 //        System.out.println("overflow");
  488.                 int iLret1=0;
  489.           char* abyte13 = divideDataBy8Bits(ai, abyte1, k3,i + 32,iLret1);
  490.                

  492.                 char* abyte14 = calculateRSECC(abyte13, abyte7[0], abyte9, k3, k2,iLret1,j3);               
  493.        
  494.                 char** abyte15=new char*[l3];
  495.                 for( n1 = 0; n1 <l3; n1++)
  496.                 {
  497.                         //abyte15[n1] = new char[l3];
  498.                         abyte15[n1] = new char[l3];               
  499.                 }
  500.                
  501.                 for(int j4 = 0; j4 < l3; j4++)
  502.                 {
  503.                         for(int k4 = 0; k4 < l3; k4++)
  504.                                 abyte15[k4][j4] = 0;                       
  505.                 }               

  507.                 for(int l4 = 0; l4 < k2; l4++)
  508.                 {
  509.                         char byte3 = abyte14[l4];
  510.                         for(int j5 = 7; j5 >= 0; j5--)
  511.                         {
  512.                                 int l5 = l4 * 8 + j5;
  513.                                 //if((abyte2[l5]==0)&&(abyte3[l5]==34)) AfxMessageBox("1");
  514.                                 abyte15[abyte2[l5] & 255][abyte3[l5] & 255] = (char)(255 * (byte3 & 1) ^ abyte4[l5]);
  515.                                 //byte3 = (char)((byte3 & 255) >>> 1);
  516.                                 byte3 = (char)((byte3 & 255) >> 1);
  517.                                 //byte3 = (char)((unsigned char)((byte3 & 255) >> 1));
  518.                         }                                       
  519.                 }

  521.                
  522.        
  523.                 /*for( j4 = 0; j4 < l3; j4++)
  524.                 {
  525.                         TestMsg(abyte15[j4],l3);                       
  526.                 }*/
  527.                
  528.                 for(int i5 = ai4[qrcodeVersion]; i5 > 0; i5--)
  529.                 {
  530.                         int k5 = (i5 + k2 * 8) - 1;
  531.                         abyte15[abyte2[k5] & 255][abyte3[k5] & 255] = (char)(255 ^ abyte4[k5]);
  532.                 }
  533.                
  534.        
  535.                 char byte4 = selectMask((char**)abyte15, ai4[qrcodeVersion] + k2 * 8,l3);
  536.                 char byte5 = (char)(1 << byte4);
  537.                 char byte6 = (char)(byte1 << 3 | byte4);
  538.                 CString as[32] = {
  539.                         "101010000010010", "101000100100101", "101111001111100", "101101101001011", "100010111111001", "100000011001110", "100111110010111", "100101010100000", "111011111000100", "111001011110011",
  540.                                 "111110110101010", "111100010011101", "110011000101111", "110001100011000", "110110001000001", "110100101110110", "001011010001001", "001001110111110", "001110011100111", "001100111010000",
  541.                                 "000011101100010", "000001001010101", "000110100001100", "000100000111011", "011010101011111", "011000001101000", "011111100110001", "011101000000110", "010010010110100", "010000110000011",
  542.                                 "010111011011010", "010101111101101"
  543.                 };
  544.                 for(int i6 = 0; i6 < 15; i6++)
  545.                 {                       
  546.                         char byte7=as[byte6][i6]-48;                       
  547.                         abyte15[abyte10[i6] & 255][abyte11[i6] & 255] = (char)(byte7 * 255);
  548.                         abyte15[abyte5[i6] & 255][abyte6[i6] & 255] = (char)(byte7 * 255);                       
  549.                 }

  551.                 //boolean [][]aflag1 = new boolean[l3][l3];
  552.                 bool** aflag1 = new bool*[l3];        //\\\\\\\\\\\                       
  553.                 for( n1 = 0; n1 <l3; n1++)
  554.                 {
  555.                         aflag1[n1] = new bool[l3];
  556.                 }
  557.                 int j6 = 0;
  558.                 for(int k6 = 0; k6 < l3; k6++)
  559.                 {
  560.                         for(int l6 = 0; l6 < l3; l6++)
  561.                         {
  562.                                 if((abyte15[l6][k6] & byte5) != 0 || abyte12[j6] == 49)
  563.                                         aflag1[l6][k6] = true;
  564.                                 else
  565.                                         aflag1[l6][k6] = false;
  566.                                 j6++;
  567.                         }
  568.                        
  569.                         j6++;
  570.                 }
  571.                 //delete[] aflag1;
  572.                 iLenRet=l3;
  573.                 /************************************************************************/
  574.                 /*                                删除new 变量                                                                                         */
  575.                 /************************************************************************/
  576.                 delete []ai;
  577.                 delete []abyte1;
  578.                 delete []abyte2;
  579.                 delete []abyte3;
  580.                 delete []abyte4;
  581.                 delete []abyte9;
  582.                 delete []abyte12;
  583.                 delete []abyte13;
  584.                 delete []abyte14;                               
  585.                
  586.                 for( n1 = 0; n1 <l3; n1++)
  587.                 {
  588.                         delete []abyte15[n1];
  589.                 }
  590.                 delete[] abyte15;
  591.                 return aflag1;
  592. }
  593.        
  594.         //char* Qrcode::divideDataBy8Bits(int ai[], char abyte0[],
  595. char* Qrcode::divideDataBy8Bits(int* ai, char* abyte0,
  596.                 int i,int iLen,int& iLRet)//int i,int j)               
  597.     {
  598.         //int iLen = abyte0.length; iLenAi=ai..length
  599.                 int j=iLen;
  600.         int l = 0;
  601.         int i1 = 8;
  602.         int j1 = 0;
  603.         //if(j == ai.length);
  604.         for(int i2 = 0; i2 < j; i2++)
  605.             j1 += abyte0[i2];
  606.                
  607.         int k = (j1 - 1) / 8 + 1;
  608.         char* abyte1 = new char[i];
  609.                 memset(abyte1,0,i);
  610.         for(int j2 = 0; j2 < k; j2++)
  611.             abyte1[j2] = 0;
  612.                
  613.         for(int k2 = 0; k2 < j; k2++)
  614.         {
  615.             int k1 = ai[k2];
  616.             int l1 = abyte0[k2];
  617.             bool flag = true;
  618.             if(l1 == 0)
  619.                 break;
  620.             while(flag)
  621.                 if(i1 > l1)
  622.                 {
  623.                     abyte1[l] = (char)(abyte1[l] << l1 | k1);
  624.                     i1 -= l1;
  625.                     flag = false;
  626.                 } else
  627.                 {
  628.                     l1 -= i1;
  629.                     abyte1[l] = (char)(abyte1[l] << i1 | k1 >> l1);
  630.                     if(l1 == 0)
  631.                     {
  632.                         flag = false;
  633.                     } else
  634.                     {
  635.                         k1 &= (1 << l1) - 1;
  636.                         flag = true;
  637.                     }
  638.                     l++;
  639.                     i1 = 8;
  640.                 }
  641.         }
  642.                
  643.         if(i1 != 8)
  644.             abyte1[l] = (char)(abyte1[l] << i1);
  645.         else
  646.             l--;
  647.         if(l < i - 1)
  648.         {
  649.             for(bool flag1 = true; l < i - 1; flag1 = !flag1)
  650.             {
  651.                 l++;
  652.                 if(flag1)
  653.                     abyte1[l] = -20;
  654.                 else
  655.                     abyte1[l] = 17;
  656.             }
  657.                        
  658.         }
  659.                 iLRet=i;
  660.         return abyte1;
  661.     }
  662.        
  663.     //private
  664.         //char* Qrcode::calculateRSECC(char abyte0[], char byte0, char abyte1[], int i, int j,
  665. char* Qrcode::calculateRSECC(char* abyte0, char byte0, char* abyte1, int i, int j,
  666.                 int iLen0,int iLen1)
  667.     {

  669.         //iLen1 abyte1.length  ; iLen0 abyte0.length
  670.         char** abyte2 = new char*[256];
  671.                 //char abyte2[][] = new char[256][byte0];
  672.                 int n1;
  673.                 for(n1=0;n1<256;n1++){
  674.                         abyte2[n1]=new char[byte0];
  675.                         memset(abyte2[n1],0,byte0);
  676.                 }
  677.        
  678.         try
  679.         {            
  680.                         CString s;
  681.                         s.Format("qrcode_data/rsc%d.dat" ,byte0);                                               
  682.                         CFile f1(s, CFile::modeRead);
  683.                         try
  684.                         {                       
  685.                                 //for(int i2 = 0; i2 < 256; i2++)   bufferedinputstream.read(abyte2[i2]);
  686.                                 for(int i2 = 0; i2 < 256; i2++)               
  687.                                 f1.Read(abyte2[i2], byte0);
  688.                                 f1.Close();
  689.                         }
  690.                         catch(...)
  691.                         {                       
  692.                                 f1.Close();
  693.                         }
  694.         }
  695.         catch(CException exception)
  696.         {
  697.             //exception.printStackTrace();
  698.         }
  699.         bool flag = false;
  700.         int i1 = 0;
  701.         int k1 = 0;      
  702.                
  703.                 char** abyte3 = new char*[iLen1];
  704.         char* abyte4 = new char[j];
  705.                 memset(abyte4,0,j);               
  706.                 memcpy(abyte4, abyte0, iLen0);
  707.       
  708.                 int ab3Length=0;
  709.                 for(int k = 0; k < iLen1; k++){
  710.                         ab3Length= (abyte1[k] & 255) - byte0;
  711.             abyte3[k] = new char[(abyte1[k] & 255) - byte0];
  712.                         memset(abyte3[k],0,(abyte1[k] & 255) - byte0);
  713.                 }

  715.        for(int l = 0; l < i; l++)
  716.         {
  717.          abyte3[k1][i1] = abyte0[l];
  718.                  if(++i1 >= (abyte1[k1] & 255) - byte0)
  719.             {
  720.                 i1 = 0;
  721.                 k1++;
  722.             }
  723.         }
  724.          /* for(int kkk=0;kkk<ab3Length;kkk++)
  725.           {
  726.         FILE *fp=NULL;
  727.         fp=fopen("C:\\test.txt","at+");       
  728.         fprintf(fp,"%d:  %d\r\n",kkk,abyte3[3][kkk]);
  729.         fclose(fp);
  730.           }*/

  732.                
  733.         //for(int l1 = 0; l1 < abyte1.length; l1++)
  734.                 for(int l1 = 0; l1 < iLen1; l1++)
  735.         {
  736.             //char abyte5[] = (char[])abyte3[l1].clone();                       
  737.                         int iLen5=(abyte1[l1] & 255) - byte0;
  738.                         char* abyte5=new char[iLen5];
  739.                         memset(abyte5,0,iLen5);
  740.                         for (n1=0;n1<iLen5;n1++)
  741.                         {
  742.                                 abyte5[n1]=abyte3[l1][n1];
  743.                         }
  744.                         //char* abyte5 = abyte3[l1];
  745.                        
  746.             int j2 = abyte1[l1] & 255;
  747.             int k2 = j2 - byte0;
  748.             for(int j1 = k2; j1 > 0; j1--)
  749.             {
  750.                 char byte1 = abyte5[0];
  751.                 if(byte1 != 0)
  752.                 {
  753.                     //char abyte6[] = new char[abyte5.length - 1];
  754.                                         char* abyte6 = new char[iLen5];
  755.                                         memcpy(abyte6,abyte5+1,iLen5-1);
  756.                                         abyte6[iLen5-1]=0;
  757.                     //System.arraycopy(abyte5, 1, abyte6, 0, iLen5 - 1);
  758.                     //char abyte9[] = abyte2[byte1 & 255];
  759.                                         char* abyte9 = abyte2[byte1 & 255];
  760.                                         int iLret1;
  761.                     abyte5 = calculateByteArrayBits(abyte6, abyte9, "xor",iLen5-1,byte0,iLret1);
  762.                                         //abyte5[iLen5-1]=0;                                       
  763.                                         delete [] abyte6;
  764.                 } else                               
  765.                                         if(byte0 < iLen5)
  766.                                         {
  767.                                                 //char abyte7[] = new char[abyte5.length - 1];
  768.                                                 char* abyte7 = new char[iLen5 - 1];
  769.                                                 memcpy(abyte7,abyte5+1,iLen5-1);
  770.                                                 for(n1=0;n1<iLen5-1;n1++)
  771.                                                         abyte5[n1]=abyte7[n1];
  772.                                                 //abyte5 = abyte7;
  773.                                                 delete []abyte7;
  774.                                         } else
  775.                                         {                                               
  776.                                                 //char abyte8[] = new char[byte0];
  777.                                                 char* abyte8 = new char[byte0];
  778.                                                 memcpy(abyte8,abyte5+1,iLen5-1);                                               
  779.                                         //        abyte8[byte0 - 1] = 0;       
  780.                                                 for(n1=0;n1<byte0;n1++)
  781.                                                         abyte5[n1]=abyte8[n1];
  782.                                                 //abyte5 = abyte8;
  783.                                                 delete []abyte8;
  784.                                         }

  786.             }
  787.                         memcpy(abyte4+iLen0+l1*byte0,abyte5,byte0);       
  788.                         delete []abyte5;
  789.         }
  790.        
  791.                 for(n1=0;n1<256;n1++){                       
  792.                         delete []abyte2[n1];
  793.                 }
  794.                 delete []abyte2;
  795.                

  797.                 for(n1=0;n1<iLen1;n1++){                       
  798.                         delete []abyte3[n1];
  799.                 }
  800.                 delete []abyte3;

  802.         return abyte4;
  803.     }
  804.        
  805.     //private
  806. char* Qrcode::calculateByteArrayBits(char* abyte0, char* abyte1, CString s,
  807.                 int iLen0,int iLen1,int& iLRet)
  808.     {
  809.                 char* abyte3;//
  810.                 char* abyte4;       
  811.                 int i,j,n1;
  812.                 if(iLen0 > iLen1)
  813.         {            
  814.                         i=iLen0;                       
  815.                         j=iLen1;                       
  816.                         abyte3=new char[i+1];
  817.                         abyte4=new char[j+1];                       
  818.                         memset(abyte3,0,i+1);
  819.                         for (n1=0;n1<i;n1++){
  820.                                 abyte3[n1]=abyte0[n1];                       
  821.                         }
  822.                         memset(abyte4,0,j+1);
  823.                         for (n1=0;n1<j;n1++)
  824.                         {
  825.                                 abyte4[n1]=abyte1[n1];                       
  826.                         }
  827.         } else
  828.         {            
  829.                         i=iLen1;               
  830.                         j=iLen0;       
  831.                         abyte3=new char[i+1];
  832.                         abyte4=new char[j+1];
  833.                         memset(abyte3,0,i+1);
  834.                         for (n1=0;n1<i;n1++)
  835.                         {                               
  836.                                 abyte3[n1]=abyte1[n1];                       
  837.                         }
  838.                         memset(abyte4,0,j+1);
  839.                         for (n1=0;n1<j;n1++)
  840.                         {
  841.                                 abyte4[n1]=abyte0[n1];                       
  842.                         }
  843.         }

  845.                 char* abyte2 = new char[i+1];
  846.                 memset(abyte2,0,i+1);
  847.         for(int k = 0; k < i; k++){
  848.             if(k < j)
  849.             {
  850.                 if(s == "xor")
  851.                     abyte2[k] = (char)(abyte3[k] ^ abyte4[k]);
  852.                 else
  853.                     abyte2[k] = (char)(abyte3[k] | abyte4[k]);
  854.             } else
  855.             {
  856.                 abyte2[k] = abyte3[k];
  857.             }                       
  858.                        
  859.                 }
  860.                 delete []abyte3;
  861.                 delete []abyte4;               
  862.                 return abyte2;
  863.         }
  864.        

  866. void Qrcode::TestMsg(char* myStr,int length)
  867. {
  868. //int kkk = strlen(myStr);
  869. for(int iii=0;iii<length;iii++)
  870. {
  871.         FILE *fp=NULL;
  872.         fp=fopen("C:\\test.txt","at+");       
  873.         fprintf(fp,"%d:  %d\r\n",iii,myStr[iii]);
  874.         fclose(fp);
  875. }
  876. }

  878. char Qrcode::selectMask(char** abyte0, int i,int iLen0)
  879. {
  880.         //iLen0 abyte0.GetLength();
  881.         //int j = abyte0.GetLength();               
  882.         int j = iLen0;
  883.         int ai[] = {
  884.                 0, 0, 0, 0, 0, 0, 0, 0
  885.         };


  888.         int ai1[] = {
  889.                 0, 0, 0, 0, 0, 0, 0, 0
  890.         };
  891.         int ai2[] = {
  892.                 0, 0, 0, 0, 0, 0, 0, 0
  893.         };
  894.         int ai3[] = {
  895.                 0, 0, 0, 0, 0, 0, 0, 0
  896.         };
  897.         int k = 0;
  898.         int l = 0;
  899.         int ai4[] = {
  900.                 0, 0, 0, 0, 0, 0, 0, 0
  901.         };
  902.        
  903.         for(int i1 = 0; i1 < j; i1++)
  904.         {
  905.                 int ai5[] = {
  906.                         0, 0, 0, 0, 0, 0, 0, 0
  907.                 };
  908.                 int ai6[] = {
  909.                         0, 0, 0, 0, 0, 0, 0, 0
  910.                 };
  911.                 bool aflag[] = {
  912.                         false, false, false, false, false, false, false, false
  913.                 };
  914.                 bool aflag1[] = {
  915.                         false, false, false, false, false, false, false, false
  916.                 };
  917.        
  918. for(int l1 = 0; l1 < j; l1++)
  919. {
  920. if(l1 > 0 && i1 > 0)
  921. {
  922.         k = abyte0[l1][i1] & abyte0[l1 - 1][i1] & abyte0[l1][i1 - 1] & abyte0[l1 - 1][i1 - 1] & 255;
  923.         l = abyte0[l1][i1] & 255 | abyte0[l1 - 1][i1] & 255 | abyte0[l1][i1 - 1] & 255 | abyte0[l1 - 1][i1 - 1] & 255;
  924. }
  925.                
  926.       for(int j2 = 0; j2 < 8; j2++)
  927.                         {
  928.                                 // ai5[j2] = (ai5[j2] & 63) << 1 | (abyte0[l1][i1] & 255) >>> j2 & 1;
  929.                                 // ai6[j2] = (ai6[j2] & 63) << 1 | (abyte0[i1][l1] & 255) >>> j2 & 1;//高位自动补零
  930.                                
  931.                                 int n=abyte0[l1][i1] & 255;
  932.                                 int x=j2;                               

  934.                                 ai5[j2] = (ai5[j2] & 63) << 1 |(n>>x)&((int)pow(2,32-x)-1) & 1;
  935.                                 ai6[j2] = (ai6[j2] & 63) << 1 |(n>>x)&((int)pow(2,32-x)-1) & 1;
  936.                                 //ai5[j2] = (ai5[j2] & 63) << 1 |((abyte0[l1][i1] & 255))>> j2 & 1;
  937.                                 //ai6[j2] = (ai6[j2] & 63) << 1 |((abyte0[i1][l1] & 255))>> j2 & 1;
  938.                                 // ai5[j2] = (ai5[j2] & 63) << 1 | (abyte0[l1][i1] & 255) >> j2 & 1;
  939.                                 // ai6[j2] = (ai6[j2] & 63) << 1 | (abyte0[i1][l1] & 255) >> j2 & 1;//高位自动补零
  940.                           
  941.                                
  942.                                 if((abyte0[l1][i1] & 1 << j2) != 0)
  943.                                         ai4[j2]++;
  944.                                 if(ai5[j2] == 93)
  945.                                         ai2[j2] += 40;
  946.                                 if(ai6[j2] == 93)
  947.                                         ai2[j2] += 40;
  948.                                 if(l1 > 0 && i1 > 0)
  949.                                 {
  950.                                         if((k & 1) != 0 || (l & 1) == 0)
  951.                                                 ai1[j2] += 3;
  952.                                         k >>= 1;
  953.                                         l >>= 1;
  954.                                 }
  955.                                 if((ai5[j2] & 31) == 0 || (ai5[j2] & 31) == 31)
  956.                                 {
  957.                                         if(l1 > 3)
  958.                                                 if(aflag[j2])
  959.                                                 {
  960.                                                         ai[j2]++;
  961.                                                 } else
  962.                                                 {
  963.                                                         ai[j2] += 3;
  964.                                                         aflag[j2] = true;
  965.                                                 }
  966.                                 } else
  967.                                 {
  968.                                         aflag[j2] = false;
  969.                                 }
  970.                                 if((ai6[j2] & 31) == 0 || (ai6[j2] & 31) == 31)
  971.                                 {
  972.                                         if(l1 > 3)
  973.                                                 if(aflag1[j2])
  974.                                                 {
  975.                                                         ai[j2]++;
  976.                                                 } else
  977.                                                 {
  978.                                                         ai[j2] += 3;
  979.                                                         aflag1[j2] = true;
  980.                                                 }
  981.                                 } else
  982.                                 {
  983.                                         aflag1[j2] = false;
  984.                                 }
  985.                         }
  986.                        
  987.                 }
  988.                        
  989.         }
  990.        

  992.         int j1 = 0;
  993.         char byte0 = 0;
  994.         int ai7[] = {
  995.                 90, 80, 70, 60, 50, 40, 30, 20, 10, 0,
  996.                         0, 10, 20, 30, 40, 50, 60, 70, 80, 90,
  997.                         90
  998.         };
  999.         for(int k1 = 0; k1 < 8; k1++)
  1000.         {
  1001.                 ai3[k1] = ai7[(20 * ai4[k1]) / i];
  1002.                 int i2 = ai[k1] + ai1[k1] + ai2[k1] + ai3[k1];
  1003.                 if(i2 < j1 || k1 == 0)
  1004.                 {
  1005.                         byte0 = (char)k1;
  1006.                         j1 = i2;
  1007.                 }
  1008.         }
  1009.        
  1010.         return byte0;
  1011. }
复制代码


源代码, 二维码

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:145151 发表于 2016-10-30 22:49 | 只看该作者
正在学习二维码，正是我需要的
回复

使用道具 举报

板凳
ID:171025 发表于 2017-3-15 19:58 | 只看该作者
VC的二维码真心是少，希望这个对我有参考价值
回复

使用道具 举报

地板
ID:183336 发表于 2017-3-25 16:31 | 只看该作者
最近在处理QR码打印的工作。没有思路了。。。
回复

使用道具 举报

5#
ID:183506 发表于 2017-3-26 13:19 | 只看该作者

　初学者的好资料，51黑有你更精彩
回复

使用道具 举报

6#
ID:227859 发表于 2017-8-16 10:02 | 只看该作者

最近在处理QR码打印的工作。没有思路了。。。
回复

使用道具 举报

7#
ID:227859 发表于 2017-8-16 10:13 | 只看该作者

　初来乍到，看看这个能不能用
回复

使用道具 举报

8#
ID:246457 发表于 2017-11-6 12:39 | 只看该作者
谢谢分享，刚刚开始要做一个二维码的程序
回复

使用道具 举报

9#
ID:88691 发表于 2017-11-19 16:17 | 只看该作者
点击生成是会提示如下错误，暂时尚未找到原因。

回复

使用道具 举报

10#
ID:347834 发表于 2018-6-8 20:24 | 只看该作者
能不能用啊
回复

使用道具 举报

11#
ID:668403 发表于 2019-12-19 15:18 | 只看该作者
正在找这个资料，希望有帮助
回复

使用道具 举报

12#
ID:434018 发表于 2021-11-7 14:48 | 只看该作者
Very Good Thanks!
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表