我是一个Java新手,学习int溢出!在处理一些整数时,我意识到了非常奇怪的结果。
int x = 2147483647 + 1;
x == > - 2147483648
int x = 2147483647 + 2;
x ==> -2147483647
int x = 2147483647 + 2147483647;
x ==> -2
int x = 2147483647 + 2147483648;
**compile error**
我认为整数溢出不会导致任何编译错误。此外,对于我来说,很难
来自java文档int has a minimum value of -2,147,483,648 and a maximum value of 2,147,483,647 (inclusive)。
我有一个Test.java班。
public class Test
{
public static void main(String[] args)
{
int i=2147483647; //max positive value an int can store
for(;;)
{
System.out.pr
嗨,我有一个小问题,一些代码,我不能解释我的结果。
//what happens?
public static void what() {
int number = 2147483647;
System.out.println(number + 33);
}
//Here is my solution for the probleme
public static void what() {
long number = 2147483647;
System.out.println(number + 33);
}
以int数作为变量的第一段代码给出了-214748
在gdb,
(gdb) p -2147483648
$28 = 2147483648
(gdb) pt -2147483648
type = unsigned int
既然-2147483648在int类型的范围内,为什么gdb将它作为unsigned int对待?
(gdb) pt -2147483647-1
type = int
(gdb) p -2147483647-1
$27 = -2147483648
让我们考虑一下Java中的以下表达式。
byte a = 32;
byte b = (byte) 250;
int i = a + b;
这在Java中是有效的,即使表达式byte b = (byte) 250;被迫将值250赋值给b,这超出了字节类型的范围。因此,b被赋值为-6,因此i通过语句int i = a + b;被赋值为26。
同样的事情也有可能在短的如下所示。
short s1=(short) 567889999;
虽然指定的值超出了short的范围,但此语句是合法的。
但是,对于更高的数据类型(如int、double、folat等),同样的情况也是错误的,因此,下面的情况是无
以下Fortran程序:
program test
double precision :: inf, one, zero
one = 1.d0
zero = 0.d0
inf = one/zero
write(6,*) floor( inf)
write(6,*) floor(-inf)
end program test
使用gfortran test.f95编译后,如下所示:
-2147483648
2147483647
我理解为什么这些值是4字节整数的最大值(或最小值),这是gfortran中的默认值,而floor返回一个整数。
我不明白的是他们的标志..。从数学上讲,数字线是:
-In
我刚刚开始使用Bluej来了解更多关于计算机如何存储整数的信息。我有一个小程序放在Bluej中,它将一个名为x的整数的值设置为MAX_VALUE -3,然后添加1到x 6次,每次打印一个新值。一个添加是不正确的,尽管我需要帮助理解我在不正确中得到的值,以及为什么我得到的结果是“奇怪的”。
请记住,我对计算机的语言非常天真,我正在读一本关于存储整数的书。这本书是“计算机科学”第11版,作者是J·格伦·布鲁克切尔。下面是我在BlueJ中使用的程序:
public class Add
{
public Add()
{
int i, x;
x = java.lang.In
假设我们有以下循环:
for (int i = 1; i < 2; i--)
{
cout << i << endl;
}
毫无疑问,这是一个无限的循环.不过,我的问题是,它会持续多久呢?因为我的教授说,考虑到int是4 bytes = 32 bits,它可以从-2147483648 to 2147483647存储一个数字。考虑到这一点,他接着说,在一个for循环中,如果它达到这些数字中的一个,并且循环仍然被编程继续(就像这个循环一样),那么这个数字就会变成正数,并且满足条件,结束循环。
我的问题是:这是怎么发生的?为什么数
我一直在探索Java如何处理整数溢出和下溢,我遇到了以下两种情况:
如果将超出范围的值直接赋值给int,则可能没有换行,这取决于转换:
long tooBigLong=2147483648L;
int integerL=(int)tooBigLong;
double tooBigDouble=Math.pow(2, 31);
int integerD=(int)tooBigDouble;
结果:
Converted from Long to int: -2147483648
Converted from Double to int: 2147483647
似乎
当我试图向表中添加几个特定数据时,出现了一个奇怪的错误。下面是我的MySQL命令。
CREATE TABLE IF NOT EXISTS `phonenumbers` (
`id` int(11) NOT NULL,
`number` int(11) NOT NULL,
`added` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB AUTO_INCREMENT=30 DEFAULT CHARSET=latin1;
INSERT INTO `phonenumberverifier`.`phonenumbers
他有什么正确的方法来验证JavaScript数字作为Java呢?
–2147483648 < n < 2147483647
IsNumeric(2147483648) --> true: which is > int
parseInt("2147483648") --> 2147483648 : which is > int
在Python中,当int大于2**31时,它会变成long:
a = 2147483647 a + 1 = 2147483648
b = -2147483648 b - 1 = -2147483649
但我需要像C中的int那样的Python int溢出:
a = 2147483647 a + 1 = -2147483648
b = -2147483648 b - 1 = 2147483647
有可能吗?提前感谢!
我对int值的范围有疑问。
int x=2147483647; /*NO Error--this number is the maximum range
of int value no error*/
int y=2147483648; /*Error--one more than the
maximum range of int*/
int z=2147483647+1; /*No Error even though it is one more
我实现了以下函数来模拟if-then-else:
int foo(int x, int y, int z) {
int negOne = (1<<31)>>31;
int test = !(~x + !x) + negOne;
int ans = (test & y) | (~test & z);
return ans;
}
我有一定的限制,上面的部分有点小技巧,但它是有效的。test仅计算为0或-1。
赋值使用特定的编译器,在x= 0、y= -2147483648和z= 2147483647的情况下,编译器声明我的代码返回-2147
假设,我有一个简单的方法:
public int add(int a, int b) {
return a + b;
}
如果我用max int值运行它
add(2147483647, 2147483647);
我得到了-2。我发现,如果我们溢出int,然后转到最小整数值(-2147483648)并继续添加。
我们来算一算吧。如果我添加2147483647 + 2147483647,我应该得到-1,因为
-2147483648 + 2147483647 = -1
那我为什么要得到-2
我的代码中有下面一行
signed int test_case= -2147483648;
它生成错误:
C4146一元减号运算符应用于无符号类型,结果仍未带符号
但这仍然与teh有符号整数类型的数据范围有关:
__int32签名,int,int -2,147,483,648至2,147,483,647
奇怪的事情是分配它,因为签名的长给出了同样的错误,即
signed long test_case= -2147483648;
下面的更改编译OK:
signed int test_case= -2147483647;
signed int test_case= 2147483
我正在测试Java (SE7)如何通过以下代码处理超过其最大值的int:
int index = 2147483647;//the maximum value of int
long size = 2147483648L; //More than the maximum value of int by 1
int safeCounter=0; //To prevent the infinite loop
while (index<size)
{
System.out.println("Index now is : "+index);//show the int v
有人能像我五岁一样向我解释为什么在Java中表示整数的四种基元类型中有两种行为不同吗?AFAIK所有四个都是有符号的,它们都使用最重要的位作为符号位,那么为什么字节和空行为正常,而int和长动作,那么,奇怪?甲骨文文档中解释这一点的片段将是完美的。
byte a = (byte) (Math.pow(2, 7)-1); //127 - as expected
short b = (short) (Math.pow(2, 15)-1); //32767 - as expected
int c = (int) (Math.pow(2, 31)-1); //2147483647 - as expec
根据MSDN ():
不带后缀的十进制常量的类型为int、long int或无符号长int。可以表示常量值的这三种类型中的第一种类型是分配给常量的类型。
在上运行以下代码
void verify_type(int a){printf("int [%i/%#x]\n", a, a);}
void verify_type(unsigned int a){printf("uint [%u/%#x]\n", a, a);}
void verify_type(long a){printf("long [%li/%#lx]\n", a, a);}
v
我正在学习不同数据类型的特点。例如,这个程序越来越多地以四种不同的格式输出2的功能:integer, unsigned integer, hexadecimal, octal
#include<stdio.h>
int main(int argc, char *argv[]){
int i, val = 1;
for (i = 1; i < 35; ++i) {
printf("%15d%15u%15x%15o\n", val, val, val, val);
val *= 2;
我最近遇到的问题需要根据整数类型的位来进行边界的整数运算。
例如,使用i32整数执行add操作,下面是一段伪代码来表示这个想法:
sum = a + b
max(min(sum, 2147483647), -2147483648)
// if the sum is larger than 2147483647, then return 2147483647.
// if the sum is smaller than -2147483648, then return -2147483648.
为了实现这一点,我天真地编写了以下丑陋的代码:
fn i32_add_handling_by_cas
我刚刚开始自学C++,并开始学习整数溢出。出于好奇,我编写了一些测试,以了解某些整数值会发生什么。
这是我的节目:
#include <iostream>
int main()
{
int x(0);
std::cout << x << std::endl;
x = x + 2147483647;
std::cout << x << std::endl;
x = x + 1;
std::cout << x << std::endl;
std::cou
我有一个任务要编写一个程序集例程,它可以从C中读取并声明如下:
extern int solve_equation(long int a, long int b,long int c, long int *x, long int *y);
找到方程的解。
a * x + b * y = c
在-2147483648 <x, y <2147483647中,检查所有选项。
如果找到解决方案和另一个0,则从例程返回的值将为1。
您必须考虑到计算结果:a * x, b * y, a * x + b * y可以超过32位。
.MODEL SMALL
.DATA
C DQ ?
SUM DQ