LargeInteger

最新推荐文章于 2017-11-15 09:31:06 发布
最新推荐文章于 2017-11-15 09:31:06 发布
阅读量593 收藏
点赞数 1
分类专栏： 源代码 文章标签： byte null 存储 数据结构 算法 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daybreaker/article/details/3009194
版权
 
  1. import java.math.BigInteger;
  3. /**  
  4.  * 超大整数加减乘除：  
  5.  * 题目要求：如果系统要使用超大整数（超过long的范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数的加法运算  
  6.  * @author Jason Huang  
  7.  *  
  8.  */ 
  9. public class LargeInteger {
  10.     // 第一位存储符号，第二位开始，从低位到高位存储数据，每个byte存储十进制数字两位，即该存储结构为100进制
  11.     private byte[] data = null;
  13.     private LargeInteger(byte[] data) {
  14.         if (data == null) {
  15.             throw new NumberFormatException();
  16.         }
  17.         this.data = copy(data, -1);
  18.     }
  20.     public LargeInteger(LargeInteger num) {
  21.         this(num.data);
  22.     }
  24.     public LargeInteger(String exp) {
  25.         // 转换成char array
  26.         char[] chars = exp.toCharArray();
  27.         // 获取第一个字母
  28.         char chr = chars[0];
  29.         // 获取左边第一个有效数字的位置
  30.         int left = (chr == '-' || chr == '+') ? 1 : 0;
  31.         // 获取byte array的长度
  32.         int length = (chars.length - left + 3) / 2;
  33.         // 建立byte array
  34.         data = new byte[length];
  35.         // 存储正负符号
  36.         data[0] = (byte) (chr == '-' ? 0x1 : 0x0);
  38.         int index = 1;
  39.         // 从低位到高位处理数字
  40.         for (int i = chars.length - 1; i >= left;) {
  41.             // 个位数
  42.             int num1 = chars[i--] - '0';
  43.             // 十位数
  44.             int num10 = i >= left ? chars[i--] - '0' : 0;
  46.             // 含有非法字符时抛出错误
  47.             if (num1 < 0 || num1 > 9 || num10 < 0 || num10 > 9) {
  48.                 throw new NumberFormatException();
  49.             }
  51.             data[index++] = (byte) (num10 * 10 + num1);
  52.         }
  53.     }
  55.     private static byte[] copy(byte[] bytes, int append) {
  56.         if (bytes == null) {
  57.             throw new NumberFormatException();
  58.         }
  60.         if (bytes.length <= 1) {
  61.             return new byte[2];
  62.         }
  64.         //System.out.println("copy1: " + toString(bytes));
  65.         int length = bytes.length;
  66.         int right = length - 1;
  67.         if (append >= 0) {
  68.             length += append;
  69.         } else {
  70.             for (; right >= 2; right--) {
  71.                 if (bytes[right] > 0x0) {
  72.                     break;
  73.                 }
  74.             }
  75.             length = right + 1;
  76.         }
  78.         byte[] other = new byte[length];
  79.         for (int i = 0; i <= right; i++) {
  80.             other[i] = bytes[i];
  81.         }
  83.         if (isZero(other)) {
  84.             other[0] = 0x0;
  85.         }
  86.         //System.out.println("copy2: " + toString(other));
  87.         return other;
  88.     }
  90.     private static byte[] subarray(byte[] bytes, int beginIndex, int length) {
  91.         if (bytes == null || bytes.length <= 1) {
  92.             throw new NumberFormatException();
  93.         }
  95.         //System.out.println("subarray: " + toString(bytes));
  96.         //System.out.println("beginIndex: " + beginIndex);
  97.         //System.out.println("length: " + length);
  98.         if (beginIndex < 0 || length < 1) {
  99.             //System.out.println("beginIndex: " + beginIndex);
  100.             //System.out.println("length: " + length);
  101.             //System.out.println("bytes.length: " + bytes.length);
  102.             throw new IndexOutOfBoundsException();
  103.         }
  105.         byte[] other = new byte[length];
  106.         other[0] = bytes[0];
  107.         for (int i = 1; i < length && i + beginIndex < bytes.length; i++) {
  108.             //System.out.println("i: " + i);
  109.             //System.out.println("beginIndex: " + beginIndex);
  110.             //System.out.println("length: " + length);
  111.             //System.out.println("bytes.length: " + bytes.length);
  112.             other[i] = bytes[i + beginIndex];
  113.         }
  115.         //System.out.println("other: " + toString(other));
  116.         return other;
  117.     }
  119.     private static byte[] shift(byte[] bytes, int n) {
  120.         if (bytes == null || bytes.length <= 1) {
  121.             throw new NumberFormatException();
  122.         }
  124.         byte[] other = new byte[bytes.length + n];
  125.         other[0] = bytes[0];
  126.         for (int i = 1; i < bytes.length; i++) {
  127.             other[i + n] = bytes[i];
  128.         }
  130.         return other;
  131.     }
  133.     private static byte[] copy(int[] nums) {
  134.         if (nums == null) {
  135.             throw new NumberFormatException();
  136.         }
  138.         if (nums.length <= 1) {
  139.             return new byte[2];
  140.         }
  142.         //System.out.println("copy1: " + toString(nums));
  143.         byte[] other = new byte[nums.length];
  144.         other[0] = (byte) nums[0];
  145.         int over = 0;
  146.         int num = 0;
  147.         for (int i = 1; i < nums.length; i++) {
  148.             over += nums[i];
  149.             other[i] = (byte) (over % 100);
  150.             over /= 100;
  151.         }
  152.         return copy(other, -1);
  153.     }
  155.     public int signum() {
  156.         return compareTo(this.data, new byte[2]);
  157.     }
  159.     private static byte[] abs(byte[] bytes) {
  160.         byte[] other = copy(bytes, -1);
  161.         other[0] = 0x0;
  162.         return other;
  163.     }
  165.     public static LargeInteger abs(LargeInteger num) {
  166.         return new LargeInteger(abs(num.data));
  167.     }
  169.     public LargeInteger abs() {
  170.         return new LargeInteger(abs(this.data));
  171.     }
  173.     private static byte[] negate(byte[] bytes) {
  174.         byte[] other = copy(bytes, -1);
  175.         other[0] ^= 0x1;
  176.         return other;
  177.     }
  179.     public static LargeInteger negate(LargeInteger num) {
  180.         return new LargeInteger(negate(num.data));
  181.     }
  183.     public LargeInteger negate() {
  184.         return new LargeInteger(negate(this.data));
  185.     }
  187.     private static boolean isZero(byte[] bytes) {
  188.         if (bytes == null) {
  189.             throw new NumberFormatException();
  190.         }
  192.         for (int i = 1; i < bytes.length; i++) {
  193.             if (bytes[i] != 0x0) {
  194.                 return false;
  195.             }
  196.         }
  197.         return true;
  198.     }
  200.     private static int compareTo(byte[] bytes1, byte[] bytes2) {
  201.         if (bytes1 == null || bytes2 == null) {
  202.             throw new NumberFormatException();
  203.         }
  205.         if (isZero(bytes1) && isZero(bytes2)) {
  206.             return 0;
  207.         } else if (isZero(bytes1)) {
  208.             return bytes2[0] == 0x1 ? 1 : -1;
  209.         } else if (isZero(bytes2)) {
  210.             return bytes1[0] == 0x1 ? -1 : 1;
  211.         } else if (bytes1[0] > bytes2[0]) {
  212.             return -1;
  213.         } else if (bytes1[0] < bytes2[0]) {
  214.             return 1;
  215.         } else if (bytes1[0] == 0x1) {
  216.             return compareTo(abs(bytes2), abs(bytes1));
  217.         }
  219.         byte[] other1 = copy(bytes1, -1);
  220.         byte[] other2 = copy(bytes2, -1);
  222.         if (other1.length < other2.length) {
  223.             return -1;
  224.         } else if (other1.length > other2.length) {
  225.             return 1;
  226.         } else {
  227.             for (int i = other1.length - 1; i >= 1; i--) {
  228.                 if (other1[i] < other2[i]) {
  229.                     return -1;
  230.                 } else if (other1[i] > other2[i]) {
  231.                     return 1;
  232.                 }
  233.             }
  234.             return 0;
  235.         }
  236.     }
  238.     public static int compareTo(LargeInteger num1, LargeInteger num2) {
  239.         return compareTo(num1.data, num2.data);
  240.     }
  242.     public int compareTo(LargeInteger num) {
  243.         return compareTo(this.data, num.data);
  244.     }
  246.     private static byte[] add(byte[] data1, byte[] data2) {
  247.         if (data1 == null || data2 == null) {
  248.             throw new NumberFormatException();
  249.         }
  251.         if (data1[0] != data2[0]) {
  252.             // 如果正负号相异，则A+B = A-(-B)
  253.             return subtract(data1, negate(data2));
  254.         }
  256.         //System.out.println("data1: " + toString(data1));
  257.         //System.out.println("data2: " + toString(data2));
  258.         // 复制A，B，并加长一位，以保证进位
  259.         int length = data1.length > data2.length ? data1.length + 1 : data2.length + 1;
  260.         // byte1复制A，被加数，并作为结果
  261.         byte[] byte1 = copy(data1, length - data1.length);
  262.         // byte2复制B，加数
  263.         byte[] byte2 = copy(data2, length - data2.length);
  264.         // 因为AB同正负号，所以符号不变
  265.         byte1[0] = data1[0];
  266.         // 进位
  267.         int over = 0;
  268.         // 运算位
  269.         int num = 0;
  270.         // 从低位到高位相加计算
  271.         for (int i = 1; i < byte1.length; i++) {
  272.             // 相应位再加进位，相加
  273.             num = byte1[i] + byte2[i] + over;
  274.             //System.out.println("num: " + num);
  275.             if (num >= 100) {
  276.                 // 有进位
  277.                 over = 1;
  278.                 num -= 100;
  279.             } else {
  280.                 // 无进位
  281.                 over = 0;
  282.             }
  283.             byte1[i] = (byte) num;
  284.         }
  285.         return byte1;
  286.     }
  288.     public LargeInteger add(LargeInteger... nums) {
  289.         byte[] augend = this.data;
  290.         for (LargeInteger num : nums) {
  291.             augend = add(augend, num.data);
  292.         }
  293.         return new LargeInteger(augend);
  294.     }
  296.     private static byte[] subtract(byte[] data1, byte[] data2) {
  297.         if (data1 == null || data2 == null) {
  298.             throw new NumberFormatException();
  299.         }
  301.         //System.out.println("data1: " + toString(data1));
  302.         //System.out.println("data2: " + toString(data2));
  303.         if (data1[0] != data2[0]) {
  304.             // 如果正负号相异，则A-B = A+(-B)
  305.             return add(data1, negate(data2));
  306.         } else if (compareTo(abs(data1), abs(data2)) < 0) {
  307.             // 如果A的绝对值>B的绝对值，则A-B = -(B-A)，以保证结果与被减数同符号
  308.             return negate(subtract(data2, data1));
  309.         }
  311.         // data复制A，被减数，并作为结果
  312.         byte[] data = copy(data1, 0);
  313.         // 结果与被减数同符号
  314.         data[0] = data1[0];
  315.         // 退位
  316.         int over = 0;
  317.         // 运算位
  318.         int num = 0;
  319.         for (int i = 1; i < data.length; i++) {
  320.             // 相应位相减，再减退位
  321.             num = data[i] - (i >= data2.length ? 0 : data2[i]) - over;
  322.             //System.out.println("num: " + num);
  323.             if (num < 0) {
  324.                 // 有退位
  325.                 over = 1;
  326.                 num += 100;
  327.             } else {
  328.                 // 无退位
  329.                 over = 0;
  330.             }
  331.             data[i] = (byte) num;
  332.         }
  333.         return data;
  334.     }
  336.     public LargeInteger subtract(LargeInteger... nums) {
  337.         byte[] minuend = this.data;
  338.         for (LargeInteger num : nums) {
  339.             minuend = subtract(minuend, num.data);
  340.         }
  341.         return new LargeInteger(minuend);
  342.     }
  344.     private static byte[] multiply(byte[] data1, byte[] data2) {
  345.         if (data1 == null || data2 == null) {
  346.             throw new NumberFormatException();
  347.         }
  349.         //System.out.println("data1: " + toString(data1));
  350.         //System.out.println("data2: " + toString(data2));
  351.         int[] data = new int[data1.length + data2.length];
  352.         data[0] = data1[0] ^ data2[0];
  354.         int num = 0;
  355.         for (int i = 1; i < data1.length; i++) {
  356.             for (int j = 1; j < data2.length; j++) {
  357.                 num = data1[i] * data2[j];
  358.                 data[i + j - 1] += num;
  359.             }
  360.         }
  362.         return copy(data);
  363.     }
  365.     public LargeInteger multiply(LargeInteger... nums) {
  366.         byte[] multiplicand = this.data;
  367.         for (LargeInteger num : nums) {
  368.             multiplicand = multiply(multiplicand, num.data);
  369.         }
  370.         return new LargeInteger(multiplicand);
  371.     }
  373.     private static byte[][] divide(byte[] data1, byte[] data2) {
  374.         if (data1 == null || data2 == null) {
  375.             throw new NumberFormatException();
  376.         } else if (compareTo(data2, new byte[2]) == 0) {
  377.             //System.out.println("data2: " + toString(data2));
  378.             throw new ArithmeticException();
  379.         }
  381.         //System.out.println("data1: " + toString(data1));
  382.         //System.out.println("data2: " + toString(data2));
  383.         byte[] bytes1 = abs(copy(data1, -1));
  384.         byte[] bytes2 = abs(copy(data2, -1));
  385.         byte[][] result = new byte[bytes1.length - bytes2.length + 2][2];
  387.         if (bytes1.length < bytes2.length) {
  388.             result[0] = new byte[2];
  389.             result[1] = bytes1;
  390.             return result;
  391.         }
  393.         byte[] result1 = new byte[bytes1.length - bytes2.length + 2];
  394.         result1[0] = (byte) (data1[0] ^ data2[0]);
  396.         for (int i = result1.length - 1; i >= 1; i--) {
  397.             //System.out.println("bytes1.length : " + bytes1.length);
  398.             //System.out.println("bytes2.length : " + bytes2.length);
  399.             //System.out.println("i: " + i);
  400.             byte[] num2 = shift(bytes2, 1);
  401.             byte[] num1 = subarray(bytes1, i - 1, num2.length);
  402.             //System.out.println("bytes1: " + toString(bytes1));
  403.             //System.out.println("num1  : " + toString(num1));
  404.             //System.out.println("num2  : " + toString(num2));
  405.             for (int j = 99; j > 0; j--) {
  406.                 num2 = subtract(num2, bytes2);
  407.                 //System.out.println("j: " + j);
  408.                 //System.out.println("num1: " + toString(num1));
  409.                 //System.out.println("num2: " + toString(num2));
  410.                 if (compareTo(num1, num2) >= 0) {
  411.                     result1[i] = (byte) j;
  412.                     bytes1 = subtract(bytes1, shift(num2, i - 1));
  413.                     break;
  414.                 }
  415.             }
  416.         }
  418.         result[0] = result1;
  420.         bytes1[0] = data1[0];
  421.         result[1] = bytes1;
  423.         return result;
  424.     }
  426.     public LargeInteger divide(LargeInteger... nums) {
  427.         byte[] quotient = this.data;
  428.         for (LargeInteger num : nums) {
  429.             quotient = divide(quotient, num.data)[0];
  430.         }
  431.         return new LargeInteger(quotient);
  432.     }
  434.     public LargeInteger remainder(LargeInteger num) {
  435.         byte[] remainder = divide(this.data, num.data)[1];
  436.         return new LargeInteger(remainder);
  437.     }
  439.     public LargeInteger mod(LargeInteger num) {
  440.         if (num.data == null) {
  441.             throw new NumberFormatException();
  442.         } else if (compareTo(num.data, new byte[2]) <= 0) {
  443.             throw new ArithmeticException();
  444.         }
  446.         byte[] remainder = divide(this.data, num.data)[1];
  447.         //System.out.println("remainder: " + toString(remainder));
  448.         return new LargeInteger(remainder[0] == 0x0 ? remainder : add(num.data, remainder));
  449.     }
  451.     public String toString() {
  452.         return toString(data);
  453.     }
  455.     private static String toString(byte[] data) {
  456.         // 验证数据
  457.         if (data == null || data.length <= 1) {
  458.             return null;
  459.         }
  461.         byte[] bytes = copy(data, -1);
  463.         // 获得数据长度
  464.         int length = bytes.length;
  465.         // 设置输出char array及从低位到高位进行处理的索引
  466.         int index = length + length;
  467.         char[] chars = new char[index--];
  469.         for (int i = 1; i < length; i++) {
  470.             // 获得个位数
  471.             int num1 = bytes[i] % 10;
  472.             // 获得十位数
  473.             int num10 = bytes[i] / 10;
  474.             // 保存个位数的字符
  475.             chars[index--] = (char) (bytes[i] % 10 + '0');
  476.             // 保存十位数的字符
  477.             chars[index--] = (char) (bytes[i] / 10 + '0');
  478.         }
  480.         // 若最高位是'0'，截去
  481.         int left = chars[2] == '0' ? 3 : 2;
  482.         // 设置正负符号
  483.         if (bytes[0] == 0x1) {
  484.             chars[--left] = '-';
  485.         }
  486.         // 返回字符串
  487.         return new String(chars, left, chars.length - left);
  488.     }
  490.     public static void main(String[] args) {
  491.         System.out.println("题目要求：如果系统要使用超大整数（超过long的范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数的加法运算");
  492.         String str1 = "7363246083486034683046834068860303406834063467340660286027670238403508439035870357057037452750657194361385618374019364013560156019406349215631248654728652462263";
  493.         String str2 = "-890450326502467843206225206846783926523485737101634543894739462923749016316021651061090106189734913864619057083749828964002176309116341493496";
  494.         String str3 = "64068204572572309572305203498204327203957234853207432074230653057026723";
  495.         LargeInteger num1 = new LargeInteger(str1);
  496.         LargeInteger num2 = new LargeInteger(str2);
  497.         LargeInteger num3 = new LargeInteger(str3);
  498.         BigInteger int1 = new BigInteger(str1);
  499.         BigInteger int2 = new BigInteger(str2);
  500.         BigInteger int3 = new BigInteger(str3);
  501.         //System.out.println("num2 : " + num2);
  502.         //System.out.println("shift: " + toString(shift(num2.data, 1)));
  503.         //System.out.println("subarray: " + toString(subarray(num2.data, 1, 5)));
  504.         System.out.println("result1: " + num1);
  505.         System.out.println("result1: " + int1);
  506.         System.out.println("result2: " + num2);
  507.         System.out.println("result2: " + int2);
  508.         System.out.println("negate: " + num1.negate());
  509.         System.out.println("negate: " + int1.negate());
  510.         System.out.println("abs: " + num2.abs());
  511.         System.out.println("abs: " + int2.abs());
  512.         System.out.println("add1: " + num1.add(num2));
  513.         System.out.println("add1: " + int1.add(int2));
  514.         System.out.println("add2: " + num1.add(num2, num2, num2));
  515.         System.out.println("add2: " + int1.add(int2).add(int2).add(int2));
  516.         System.out.println("add3: " + num2.add(num2.negate()));
  517.         System.out.println("add3: " + int2.add(int2.negate()));
  518.         System.out.println("add4: " + num2.add(num3.negate()));
  519.         System.out.println("add4: " + int2.add(int3.negate()));
  520.         System.out.println("add5: " + num2.add(num2));
  521.         System.out.println("add5: " + int2.add(int2));
  522.         System.out.println("subtract4: " + num2.subtract(num3));
  523.         System.out.println("subtract4: " + int2.subtract(int3));
  524.         System.out.println("subtract5: " + (new LargeInteger("10000")).subtract((new LargeInteger("1"))));
  525.         System.out.println("subtract5: " + (new BigInteger("10000")).subtract((new BigInteger("1"))));
  526.         System.out.println("subtract6: " + (new LargeInteger("10000")).subtract((new LargeInteger("9999"))));
  527.         System.out.println("subtract6: " + (new BigInteger("10000")).subtract((new BigInteger("9999"))));
  528.         System.out.println("subtract7: " + (new LargeInteger("1")).subtract((new LargeInteger("10000"))));
  529.         System.out.println("subtract7: " + (new BigInteger("1")).subtract((new BigInteger("10000"))));
  530.         System.out.println("subtract8: " + (new LargeInteger("9999")).subtract((new LargeInteger("10000"))));
  531.         System.out.println("subtract8: " + (new BigInteger("9999")).subtract((new BigInteger("10000"))));
  532.         System.out.println("subtract9: " + (new LargeInteger("-9999")).subtract((new LargeInteger("10000"))));
  533.         System.out.println("subtract9: " + (new BigInteger("-9999")).subtract((new BigInteger("10000"))));
  534.         System.out.println("multiply1: " + num1.multiply(num2));
  535.         System.out.println("multiply1: " + int1.multiply(int2));
  536.         System.out.println("multiply2: " + num1.multiply(num2, num3));
  537.         System.out.println("multiply2: " + int1.multiply(int2).multiply(int3));
  538.         System.out.println("divide5: " + (new LargeInteger("130000")).divide(new LargeInteger("4")));
  539.         System.out.println("divide5: " + (new BigInteger("130000")).divide(new BigInteger("4")));
  540.         System.out.println("divide6: " + (new LargeInteger("-13")).divide(new LargeInteger("4")));
  541.         System.out.println("divide6: " + (new BigInteger("-13")).divide(new BigInteger("4")));
  542.         System.out.println("divide7: " + (new LargeInteger("13")).divide(new LargeInteger("-4")));
  543.         System.out.println("divide7: " + (new BigInteger("13")).divide(new BigInteger("-4")));
  544.         System.out.println("divide8: " + (new LargeInteger("-13")).divide(new LargeInteger("-4")));
  545.         System.out.println("divide8: " + (new BigInteger("-13")).divide(new BigInteger("-4")));
  546.         System.out.println("mod5: " + (new LargeInteger("13")).mod(new LargeInteger("4")));
  547.         System.out.println("mod5: " + (new BigInteger("13")).mod(new BigInteger("4")));
  548.         System.out.println("mod6: " + (new LargeInteger("-13")).mod(new LargeInteger("4")));
  549.         System.out.println("mod6: " + (new BigInteger("-13")).mod(new BigInteger("4")));
  550.         System.out.println("divide1: " + num1.divide(num1));
  551.         System.out.println("divide1: " + int1.divide(int1));
  552.         System.out.println("divide2: " + int1.divide(int1.negate()));
  553.         System.out.println("divide2: " + num1.divide(num1.negate()));
  554.         System.out.println("divide3: " + num2.divide(num2.negate().add(num3)));
  555.         System.out.println("divide3: " + int2.divide(int2.negate().add(int3)));
  556.         System.out.println("divide4: " + num2.divide(num2.negate().subtract(num3)));
  557.         System.out.println("divide4: " + int2.divide(int2.negate().subtract(int3)));
  558.         System.out.println("mod1: " + num2.mod(num3));
  559.         System.out.println("mod1: " + int2.mod(int3));
  560.         System.out.println("mod2: " + num2.negate().mod(num3));
  561.         System.out.println("mod2: " + int2.negate().mod(int3));
  562.     }
  563. }
daybreaker
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LARGE_INTEGER 大整数结构体的解析
shuixiaowei0530的博客
03-12 2363
在“WinNT.h”文件中定义了一个结构体LARGE_INTEGER，十分巧妙#if defined(MIDL_PASS)typedef struct _LARGE_INTEGER {#else // MIDL_PASStypedef union _LARGE_INTEGER {    struct {        DWORD LowPart;        LONG HighPart;    ...
Large-integer.rar_ large integer_integer加减乘除_visual c
09-20
实现较大整数的加减乘除等运算，可运行。。。。
大整数加减法（C++实现）
庚午步雲
08-16 5468
头文件：LargeInteger.h #ifndef LARGEINTEGER_H_INCLUDED #define LARGEINTEGER_H_INCLUDED #include using namespace std; class LargeInteger {// 大整数（用字符串表示） public: LargeInteger() { this->numStr = "0"
LARGE_INTEGER解析
听风的雨滴
04-01 2万+
驱动开发中，我们除了可以使用LONGLONG这个表示64位结构的数据外。还可以使用一个叫做LARGE_INTEGER的数据结构来表示64位数据。它的定义如下 typedef union _LARGE_INTEGER { struct { ULONG LowPart; LONG HighPart; } DUMMYSTRUCTNAME; str
LARGE_INTEGER解析和使用
thanklife的专栏
09-21 1万+
这里解释前面碰到的LARGE_INTEGER结构。与可能的误解不同，64位数据并非要在64位操作系统下才能使用。在VC中，64位数据的类型为__int64。定义写法如下：       __int64 file_offset;       上面之所以定义的变量名为file_offset，是因为文件中的偏移量是一种常见的要使用64位数据的情况。同时，文件的大小也是如此（回忆上一
LARGE_INTEGER.zip_LARGE_INTEGER_visual c
09-19
关于C++精确测试 程序运行是 所需时间
Large-integer arithmetic in BASIC-开源
04-26
用于大整数算术的BASIC库，以及一些数论模块。
使用LARGE_INTEGER查看系统运行时间
07-03
windows ce是一个实时操作,因此提供了不少的优先级给用户.优先级最高为0级,也就是说使用0优先级的程序, 可以挂起整个系统, 来运行你的程序 对于实时性比较的领域, 我们作为程序员的 应该清楚的知道你的程序模块运行...
大整數的相加
03-02
This is a .c file that can operator
关于ULARGE_INTEGER的运算！
ErenNo1的专栏
10-14 7978
ULARGE_INTEGER Union The ULARGE_INTEGER structure is used to specify a 64-bit unsigned integer value. typedef union _ULARGE_INTEGER { struct { DWORD LowPart; DWORD HighPart; }; struct
java Integer number too large
koreyoshi326的博客
05-21 1万+
Integer number too large
Java中Integer的最大值和最小值
热门推荐
白衣
11-15 14万+
Java中Integer的最大值和最小值 . Java Byte的最大值和最小值 . Java float的最大值和最小值 . Java long的最大值和最小值 .
BigInteger类详解
听海的博客
04-20 8228
今天我们就来聊一聊Java内存模型，面试中面试官会通过考察你对jvm的理解更深入得了解你的水平。如果你应聘的职位涉及系统调优，如堆大小的分配、垃圾回收机制的选择、处理内存溢出、线程死锁等，对JVM这一块知识就有更高的要求。 说明：因为知识点较多，扩展开来篇幅太长，jvm系列面试题将会分解开来从内存模型，垃圾回收，类加载机制，参数调优等多个角度整理，方便大家阅读。 Java 内存模型
java基础-BigInteger的使用
敲代码的乔帮主
11-12 1万+
大数相乘这个点，在java里算是比较冷门的知识了吧，我一开始也没当回事，然而今年腾讯实习生春招笔试题告诉我实在是too young，在编程题里就有一道大数相乘的题目，结果当时我就懵逼了。现在补一下吧。 BigInteger不是基本数据类型之一，它其实更像String,是Java里的一个类，然而它的初始化方式却没有String那么方便可以直接赋值，而是跟其他自定义的类一样，要调用它的构造器进行初始化
LARGE_INTEGER类型 和 QueryPerformanceFrequency()
weixin_34212189的博客
09-17 355
LARGE_INTEGER LARGE_INTEGER是union；用于表示一64位有符号整数值.其他定义如下： typedef union _LARGE_INTEGER { struct { DWORD LowPart; LONG HighPart;...
large integer implicitly trunc
最新发布
03-16
"large integer implicitly trunc" 的意思是大整数被隐式截断。这通常发生在计算机程序中，当一个大整数超出了计算机所能处理的范围时，它会被截断为一个较小的整数。这可能会导致计算结果不准确或错误。因此，在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值