我正在使用Ubuntu 16.04.5和GCC版本5.4.0。
我在玩sizeof()操作符,编写了下面的代码:
#include <stdio.h>
int main(int argc, char *argv[]){
long int mylint = 31331313131.1313;
printf("size of long int is %d\n", sizeof(mylint));
printf("size of long int is %d\n", sizeof(long int));
我一直认为签名乘法和除法与相应的无符号运算需要不同的电路逻辑。在另一个论坛上,有人说,无符号-ALU可以在没有任何修改的情况下使用,并给出有效的结果。
我刚用一个小程序测试了这个
#include <stdio.h>
void main()
{
short a, b;
long long c;
c = 0;
a = -32768;
do
{
b = -32768;
do
if( (int)((unsigned)a * (unsigned)b) != ((int)a * b)
考虑以下例子:
#include <stdio.h>
int main(void)
{
unsigned char a = 15; /* one byte */
unsigned short b = 15; /* two bytes */
unsigned int c = 15; /* four bytes */
long x = -a; /* eight bytes */
printf("%ld\n", x);
x = -b;
printf("%ld\n", x);
x
我最近在我的代码中发现了一个bug,我花了几个小时来调试它。
问题出在如下定义的函数中:
unsigned int foo(unsigned int i){
long int v[]={i-1,i,i+1} ;
.
.
.
return x ; // evaluated by the function but not essential how for this problem.
}
V的定义在我的开发机器(ubuntu12.04 32位,g++编译器)上没有引起任何问题,在那里无符号整数被隐式地转换为长整数,这样负值就被正确地处理了。
在不同
让platform 1的宽度为int 4字节,long为8字节。
假设platform 2的宽度为int 4字节,long的宽度与int的宽度相同。
然后给予:
unsigned int x = 2;
long signed int y = 3;
func(x * y);
在平台1上运行时,func的第一个参数的有效类型是long signed int。这是意料之中的。遵循第6.3.1.1.1.4节,unsigned int类型与signed int具有相同的等级。根据第6.3.1.1.1.3节,signed int类型的等级也低于long signed int。这将触发将乘法转换为long
我刚开始编程,我编写了以下代码,但由于某种原因,它没有显示正确的值,尽管我几乎可以肯定,我过高了值类型。
#include <limits>
#include <iostream>
int main() {
unsigned long long int imin = std::numeric_limits<unsigned long long int>::min(); // minimum value
unsigned long long int imax = std::numeric_limits<unsigned long lon
我试图以相反的顺序访问存储在向量中的值。以下代码没有显示错误:
for (long long int i = 0; i < end.size(); i++)
cout << end[end.size() - 1 - i] << "\n";
但是,下面的代码显示运行时错误:
for(long long int i = end.size()-1;i>=0;i--) cout<<end[i]<<"\n";
这两种方法有什么区别吗?
我已经写了一个函数,它必须以二进制表示返回n个位"1“。我观察到了(对我来说)意想不到的行为。
当我在for循环中使用unsigned int类型时,函数陷入了无限循环,我不知道为什么。
unsigned int countBits(unsigned long long n)
{
//your code here
int nofbits= log2(n)+1,
nofone=0;
for(int i=nofbits;i>=0;--i)
{
if(n-pow(2,i)>=0)
{
nofone+
这个问题是另一个的结果。
示例代码
#include <iostream>
int main()
{
unsigned long b = 35000000;
int i = 100;
int j = 30000000;
unsigned long n = ( i * j ) / b; // #1
unsigned long m = ( 100 * 30000000 ) / b; // #2
std::cout << n << std::endl;
std::cout << m <&l
在"C++ Primer“一书中,有人说十进制文字具有最小类型的int、long或long long,在这些类型中,文字的值与之相吻合,如果使用的文字太大而不能在最大的相关类型中匹配,则是错误的。因此,我猜,最大十进制文字是最大值long long可以容纳。但是我试过了:打印最大long long值,然后是十进制的文字值。我以为它一定会引起错误,但没关系。然后,我尝试打印一个大于unsigned long long最大值的十进制文字--它被包装起来了。
这是我的代码:
#include <iostream>
#include <limits>
using na
为什么这个程序的输出是-2147483648?
#include <iostream>
using namespace std;
int main() {
long long a=-2147483648;
a=a*-1;
cout<<a;
return 0;
}
应该是2147483648,因为它在long long的范围内。为什么这个标志没有改变?我甚至尝试过abs()函数,但结果是一样的。
更令人惊讶的是,这个程序输出2147483648:
#include <iostream>
using namespace std;
我是C的新手,还在努力理解溢出是如何发生的。假设我们有下面的buggy代码来确定一个字符串是否比另一个字符串长:
int strlonger(char *s, char *t) {
return strlen(s) - strlen(t) > 0; // let's say the first return value of strlen(s) is s1, abd the second is s2
}
我们知道它不会工作,因为返回类型的strlen()是size_t,也就是unsigned int,所以当我们有1u - 2u > 0之类的东西时,左操作数溢出。
我
最近我遇到了一个我无法理解的奇怪的C++错误。这是我的密码:
#include <bits/stdc++.h>
using namespace std;
typedef vector <int> vi;
typedef pair <int, int> ii;
#define ff first
#define ss second
#define pb push_back
const int N = 2050;
int n, k, sum = 0;
vector <ii> a;
vi pos;
int main (void) {
c
我想知道为什么这两个数字是相等的。我(也许是错误的)意识到我搞砸了我的牙龈,因为在我的牙龈里我经常这样做:
enum class SomeFlags : unsigned long long { ALL = ~0, FLAG1 = 1, FLAG2 };
我认为0是一个int,被分配给一个未签名的长,这是一个错误。
unsigned long long number1 = ~0;
/* I expect the 0 ( which is an int, to be flipped, which would make it
the max value of an unsigned int. It
我正在尝试为C#中的函数编写一个Java等价物。代码如下。
在C#中:
byte[] a = new byte[sizeof(Int32)];
readBytes(fStream, a, 0, sizeof(Int32)); //fstream is System.IO.Filestream
int answer = BitConverter.ToInt32(a, 0);
在Java中:
InputStream fstream = new FileInputStream(fileName);
DataInputStream in = new DataInputStream(fstream);
我刚开始学习C编程,我想我会从一个非常基本的问题开始,计算一个数字的阶乘。我的代码在13的阶乘之前输出正确的值,然后在输入大于13时给出错误的答案。
#include<stdio.h>
long int factorial(int);
int main()
{
int num;
long int fact;
printf("Please type the number you want factoralized: ");
scanf("%d",&num);
fact = factorial(num
我写了以下代码。任何小于50000和60000的组合都会给出正确的答案,但出于某种原因,当我使用50000和60000时,我总是得到-1294967296。有人能告诉我这是为什么吗?
#include <stdio.h>
int main()
{
int a = 50000;
int b = 60000;
int c = a * b;
printf("The product of a and b is %d",c);
return 0;
}
下面给出的代码的工作效率可以达到10位(int数据类型),但是对于超过10位数的数字,它失败了,所以我尝试了unsigned long long int。但是现在我的输出被修正为15,为什么?考虑到我对C非常陌生,我有平庸的蟒蛇背景!
我使用gcc (Ubuntu5.4.0-6 ubuntu1~16.04.1) 5.4.0 20160609
#include <stdio.h> //Get number of digits in a int
unsigned long long int get_len();
void main() {
unsigned long long
int left = std::numeric_limits<int>::min();
int right = -1;
//the code below instead of give one more than int_max gives: 18446744071562067968
unsigned long long result = left * right;
我试图查找UAC,但即使根据UAC规则,这也应该产生正确的输出。你知道为什么结果是错误的吗?
请看下面在visual studio 2012中编译的代码。
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
long long end1 = 12345678908642;
long end2 = 65537;
printf("end1 = %lld and %u\n" , end1 , end1); // line a
printf("end2 = %d and %ld and %u\n" , end2 , end2 , end2);
我目前正在修复C代码中的遗留错误。在修复此bug的过程中,我将unsigned int存储到unsigned long long中。但令我惊讶的是,当我在64位版本的GCC上编译这段代码时,数学就停止工作了。我发现问题在于,当我给long long分配一个int值时,我得到了一个看起来像0x0000000012345678的数字,但是在64位机器上,这个数字变成了0xFFFFFFFF12345678。
有人能向我解释,或者向我指出某种规范或文档,说明在更大的数据类型中存储较小的数据类型时应该发生什么,以及在C中进行此操作的合适模式是什么?
更新-代码示例
我正在做的事情是:
// Result
下面,当任何numA-D被乘以无数次时,这个数字突然变成了负数。例如,当numA乘以256 3倍时,该数字将变为负数,但如果仅乘以256两次,则不会。此项目的目的是将ip地址更改为无符号的长整型,然后将无符号的长整型更改为ip地址。
using namespace std;
unsigned long ip2long (string ipv4)
{
// variable to return
unsigned long rtn;
string A,B,C,D;
string delimiter = ".";
size_t position;
/* must parse s
在C++中,为什么long l = 0x80000000;是正的?
C++:
long l = 0x80000000; // l is positive. Why??
int i = 0x80000000;
long l = i; // l is negative
根据这个站点:,0x80000000应该是一个带符号的整数,但它似乎不是这样的,因为当它被赋值给l时,符号扩展不会发生。
Java:
long l = 0x80000000; // l is negative
int i = 0x80000000;
long l = i; // l is negative
另一方面,Java具有
我正在移植一些在uint32_t上执行模块的c代码,uint32_t适合于Java位,但我不知道如何在不转换为long的情况下对它执行模块化操作。这是我现在的代码:
int i = 0xffffffff;
long asUnsigned = Integer.toUnsignedLong(i);
int mod = (int) (asUnsigned % 42L);
我可以在不转换为long的情况下执行这个模块计算吗?
我试图理解C11标准的算术转换规则。该标准将严格递减级别的不同整数类型指定为:
long long int
long int
int
short int
char
此外,在默认情况下,所有其他类型都进行了签名,而char则根据实现的不同而被签名或未签名。所有类型都有有符号和无符号的版本。该标准还将实际类型定义为:
long double
double
float
我阅读标准的方式是,如果我们增加了。
a + b
a是实类型,b是任何整数类型,然后b转换为a类型。换句话说,如果a有float类型,b有类型long long int,那么我们首先将b转换为float,然后再进行添加,还是我读错了?