假设我有一个大小为78719476736字节的数组.请注意,在我的C代码中使用malloc动态分配此数组.假设malloc在分配了这么多内存后返回一个有效的指针.此数组的大小大于UINT_MAX(4294967295),即无符号整数的最大限制(32位)
假设我的代码看起来像下面的东西,例如
int *buf;
buf = (int*)malloc(78719476736);
这里78719476736大于4*UINT_MAX.
现在如果我必须引用buf的所有元素,那么因为buf是int*它将是32位,所以它将无法处理我使用malloc(78719476736字节)分配的所有内存元素.
我的问题是不应该将上面的代码更改为使buf为long long(64位变量),因为只有long long变量才能解决我已经分配的大内存.
改变了代码,例如
unsigned long long int buf;
buf = (unsigned long long int*)malloc(78719476736);
实际上我认为,变量buf不应该再是指针,因为任何指针都是32位宽,因此它将无法访问78719476736字节.
所以它应该是一个普通的unsigned long long int,并且我必须将malloc返回指针值转换为unsigned long long int,如上面更改的代码所示,并使用buf访问所有已分配的元素.
我在上面的假设中是否正确？
要么
我混淆/遗失了什么吗？
编辑:如果有帮助,
我正在使用Intel Core 2 Duo(64位CPU)上的WinXP桌面.因此,CPU智能访问超过4 GB的地址空间不应该是一个问题.应该为64位支持启用所有其他组件,即
a.)如何在编译时启用64位编译器支持(我使用的是Visual Studio 2005专业版)
b.)64位操作系统支持 - 我使用的是Windows XP Professional.
谢谢.
-广告.
我发现我需要计算大数到高精度.例如:5422300.8452.存储此数据的最佳方法是什么,以便简单的算术运算符可以对其进行操作？我一直在努力做Longs和Doubles的组合,但经过大量的计算后它变得复杂了.我确信有一个简单的解决方案,我还不是那么知识渊博.
好吧基本上,我想通了:我的问题是我想要保持4位小数的精度,但输入一个高位数开始截断数字.例如,我有这个:
Double Remain = (double) Math.round((double quantity/12)*10000)/10000;
这适用于较小的数字,但900000000仍然被截断为7.5的东西.
因此,我基本上需要将数字除以长度,然后取2的模数并将其除以分母,然后舍入结果.然后添加2.
有用!
在解决K&R C书中的练习时,我偶然发现了练习2.1.
起初,我为UINT_MAX作为-1,但后来我用的%u占位符,但现在它让我有相同的号码ULONG_MAX.
在这本书的附录B,他们说,UINT_MAX应该是65535和ULONG_MAX应4294967295,但在运行时的运动,它的给我两个UINT_MAX和ULONG_MAX作为4294967295.
这是为什么？
在尝试比较数据类型'int'和'long'的性能时,我遇到了这个奇怪的问题,基本上我有两个单元测试:
@Test
public void testLongOperationPerformance(){
StopWatch sw = new StopWatch();
sw.start();
long count = 0l;
for(int i = 0; i < Integer.MAX_VALUE; i ++){
count++;
}
sw.stop();
System.out.println(count);
System.out.println(sw.elaspedTimeInMilliSeconds());
}
@Test
public void testIntegerOperationPerformance(){
StopWatch sw = new StopWatch();
sw.start();
int count = 0;
for(int i = 0; i < Integer.MAX_VALUE; i ++){
count++;
}
sw.stop();
System.out.println(count);
System.out.println(sw.elaspedTimeInMilliSeconds());
}
这两个单元测试正在做同样的事情,不同的是一个使用int作为计数器的数据类型,另一个使用long.结果:
jdk6u32 (64 bit):
test with long
2147483635
96
test with int
2147483647
2
jdk7 (64 bit)
test with long
2147483647 …我正在尝试将一个非常大的输入读取为String,然后将其转换long为如下所示:[该程序适用于短输入]
输入是两个int用空格分隔的,例如:"1248614876148768372675689568324619856329856295619253291561358926935829358293587932857923857934572895729511 413241"
我的代码:
import java.io.*;
import java.math.*;
import java.util.*;
public class Solution {
public static void main(String args[] ) throws Exception {
Solution obj = new Solution();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(br.readLine());
String input[]=new String[T];
for (int i=0;i<T;i++) {
input[i] = br.readLine();
}
for (int i=0;i<T;i++){
StringTokenizer st = new StringTokenizer(input[i]," ");
BigInteger N = new BigInteger(st.nextToken());
BigInteger P = new BigInteger(st.nextToken());
System.out.println(obj.result(N,P));
}
}
}
public BigInteger result(BigInteger …我在Linux上尝试使用time -p命令,并编写了一些代码来浪费CPU周期:
#include <iostream>
using namespace std;
int main() {
long int c;
long int ss;
for(c = 0;c < 10000000;c++) {
ss += c*c;
}
cout<<ss<<endl;
return 0;
}
然而,在运行几次之后我发现了一些有趣的东西:
me@octopus:~/Desktop> ./test
1292030741067648912
me@octopus:~/Desktop> ./test
1292030742538841328
me@octopus:~/Desktop> ./test
1292030742228685600
me@octopus:~/Desktop> ./test
1292030740402651312
me@octopus:~/Desktop> ./test
1292030740207543344
me@octopus:~/Desktop> ./test
1292030740346553856
me@octopus:~/Desktop> ./test
1292030741629275040
me@octopus:~/Desktop> ./test
1292030740397307072
me@octopus:~/Desktop> ./test
1292030742928964784
me@octopus:~/Desktop> ./test
1292030741780094096
我不仅每次都得到相同的数字,正如我所料,我甚至没有得到相同的数字.这里发生了什么？
我正在用java编写一些代码并使用JSON Simple包.我在下面运行此代码
jsonObject.get( "last" ) ;
不幸的是,这可能是长的还是双倍的,解析这个值的最快/最正确的方法是什么？
会是这样的吗？
long lngLast = -1;
double dblLast = -1;
if ( jsonObject.get( "last" ).getClass().getName() == "java.lang.Long" ) {
lngLast = (long) jsonObject.get( "last" ) ;
} else {
dblLast = (double) jsonObject.get("last");
}
if ( lngLast == -1)
System.out.println( dblLast );
else
System.out.println( lngLast );
这似乎很荒谬.必须有更好的方法来做到这一点.我试图将长度转换为双倍(我相信我应该能够做到这一点？)但每次都会出错.我希望有人可以用正确或更好的方式教育我.
简单的代码没问题
long x = Integer.MAX_VALUE;
System.out.println(x * 2 + "...." + Long.MAX_VALUE);
= 4294967294....9223372036854775807
但这里发生了什么？为什么-2
System.out.println(2 * Integer.MAX_VALUE + "...." + Long.MAX_VALUE);
= -2....9223372036854775807
为什么元素是149998,编译器不会将这些转换为long？
long elements = 2 * Integer.MAX_VALUE + 150000;
System.out.println(elements + "...." + Long.MAX_VALUE);
149998....9223372036854775807
-谢谢
如果你调用以下Java方法
void processIt(long a) {
float b = a; /*do I have loss here*/
}
将long变量赋值给float变量时,是否会丢失信息？
Java语言规范说浮点类型是long的超类型.
我必须创建一个从1到100的程序,并计算从分区中得到的数字的单独产品,其余为0,1,2,3,所以基本上我必须计算4种不同的产品.
我尝试用两种方式解决这个问题,两种方式都显示错误的结果:
第一次尝试:
public class prodmod4 {
public static void main(String[] args){
int i, k=0;
long P=1;
while(k<4){
for(i=1;i<=100;i++){
if(i%4==k){
P=P*i;
}
}
System.out.printf("Produsul numerelor care au restul %d este: %d\n", k, P);
i=1;
P=1;
k++;
}
}
}
当我运行这个程序时,它给了我:
休息0的数字的乘积是0,休息1 -6661643765781265135,休息2 -2885954222765899776,休息3 -9150527387120197261
第二次尝试:
public class prodmod4v2 {
public static void main(String[] args){
int i;
long zero=1, unu=1, doi=1, trei=1;
for(i=1;i<=100;i++){
switch(i%4){
case 0:
zero=zero*i;
break;
case 1:
unu=unu*i;
break;
case 2:
doi=doi*i;
break;
case 3:
trei=trei*i;
break;
default: …