标签: overflow

短问题:

#include <iostream>

using namespace std;

int main()
{
    double **T;
    long int L_size;
    long int R_size = 100000;
    long int i,j;

    cout << "enter L_size:";
    cin >> L_size;
    cin.clear();
    cin.ignore(100,'\n');
    cout << L_size*R_size << endl;
    cout << sizeof(double)*L_size*R_size << endl;

    T = new double *[L_size];
    for (i=0;i<L_size;i++)
    {
        T[i] = new double[R_size];
    }

    cout << "press enter to fill array" << endl;
    getchar();
    for (i=0;i<L_size;i++)
    {
        for (j=0;j<R_size;j++)
        {
            T[i][j] = 10.0;
        }
    }
    cout << "allocated" << endl; …

在我的应用程序中,我有一个TextBlock,我在用户按下按钮后显示一个Double编号.此数字可以是非常小的小数或需要指数表示法的非常大的数字(即3.43e12).问题是,程序打印了这么多数字,它溢出了我的TextBlock,用户无法看到所有有效信息.

那么如何限制Double打印以便不溢出TextBlock？

我用来设置文本的代码是:

theTextBox.Text = (split * input).ToString();

编辑:有人问了具体的例子,所以我想我会澄清一些事情.我基本上希望字符串永远不会超过10个字符.这样它就适合TextBlock.我想诀窍是,这些10个字符应该何时为小数位,整数或科学记数法,这就是诀窍......

在.NET中可能溢出以产生int'-2147479552'？

确切的InvalidOperationException是

System.InvalidOperationException:值"0x-2147479552"无法转换为System.Int64.

我猜测接下来的是一个字符串,它被转换为int,但它可能是什么？

假设你有一个按递增顺序排列的值列表,除了在某些时候它们是wrap-wround

2,4,6,9,12,15,34,-2,1,4,5,7 ......

知道周期为2 ^ n,对于n的某个值,是否存在任何内置函数,或者是重新排列上述值的快速方法,以便所有数字按递增顺序排列(假设数字是可能的)？

我编写了一个将十进制数转换为二进制数的函数.我输入我的十进制数字作为long long int.它适用于小数字,但我的任务是确定计算机如何处理溢出,所以当我输入(2 ^ 63) - 1时,函数输出十进制值为9223372036854775808,二进制值等于-954437177.当我输入2 ^ 63这是64位机器无法保持的值时,我得到警告:整数常量太大而无符号且十进制常数仅在ISO C90和十进制输出中无符号值为负2 ^ 63,二进制数为0.我使用gcc作为编译器.这个结果是否正确？

代码如下:

#include <iostream>
#include<sstream>
using namespace std;
int main()
{
long long int answer;
long long dec;
string binNum;
stringstream ss;
cout<<"Enter the decimal to be converted:"<< endl;;
cin>>dec;
cout<<"The dec number is: "<<dec<<endl;
while(dec>0)
{
     answer = dec%2;
     dec=dec/2;
     ss<<answer;
     binNum=ss.str();
}
cout<<"The binary of the given number is: ";
for (int i=sizeof(binNum);i>=0;i--){
     cout<<binNum[i];}
return 0;
    }

为什么当我的溢出计算是printf()函数的参数时,float不会溢出,但是当编码计算被分配给一个单独的变量float_overflowed,并且不是printf函数的参数时,我得到了'inf'的预期结果？为什么会这样？是什么造成了这种差异？

导致我回答这个问题的代码和结果如下.

这是我的代码,当计算是一个参数时,它没有按预期执行:

float float_overflow;
float_overflow=3.4e38;
printf("This demonstrates floating data type overflow. We should  get an \'inf\' value.\n%e*10=%e.\n\n",float_overflow, float_overflow*10);     //No overflow?

结果:

This demonstrates floating data type overflow. We should  get an 'inf' value.
3.400000e+38*10=3.400000e+39.

而且,当计算不是一个论点时:

float float_upperlimit;
float float_overflowed;
float_upperlimit=3.4e38;
float_overflowed=float_upperlimit*10;
printf("This demonstrates floating data type overflow. We should  get an \'inf\' value.\n%e*10=%e.\n\n",float_upperlimit, float_overflowed);        //for float overflow

及其结果:

This demonstrates floating data type overflow. We should  get an 'inf' value.
3.400000e+38*10=inf.

是否存在在-1中存储的数组中的值的重定制？它会以一种糟糕的方式影响程序或计算机吗？我很好奇,我是编程的新手,任何澄清我都能得到真正的帮助,谢谢.

当我在操场上写这行时:

let firstBits: Int8 = 0b11111111

存在错误:存储到'Int8'时整数文字溢出

由于Int8是一个有符号值,其范围是-128到127.左边的第一位是单(减号或加号),另外7位代表值.所以二进制格式应该总共有8位.但为什么会有错误呢？

如果我这样用7位写:

let firstBits: Int8 = 0b1111111

没有错误,firstBits的值为127.

那么我应该如何将-128分配给带有二进制格式的firstBits？

我正在完成hackerrank的项目euler问题#1.我写了一个暴力解决方案来检查我的答案.它似乎是正确的,除了输入10 ^ 9.有人告诉我,正确的答案是:

233333333166666668

我要回来了:

233333333166666680

n = 1000000000
sum_of_multiples_3 = int((int((n-1)/3.0)+1) * (int((n-1)/3.0)/2.0) * 3)
sum_of_multiples_5 = int((int((n-1)/5.0)+1) * (int((n-1)/5.0)/2.0) * 5)
sum_of_multiples_15 = int((int((n-1)/15.0)+1) * (int((n-1)/15.0)/2.0) * 15)
print(sum_of_multiples_3 + sum_of_multiples_5 - sum_of_multiples_15)

在我的java教科书中,它写着"2147483647 + 1实际上是-2147483648"

我理解这是因为溢出,但为什么他们选择让它等于最小的整数值？