c语言：int型的强制类型转换是按四舍五入吗？

Posted 2023-05-11

强制类型转换int的结果只保留整数部分，不是四舍五入。

例如：

int 3.14，结果为3；

int  3.58，结果也为3。

Int是将一个数值向下取整为最接近的整数的函数。INT是数据库中常用函数中的取整函数，常用来判别一个数能否被另一个数整除。

扩展资料：

int 函数使用的注意事项：

1、 语法int(number）其中number是需要进行向下舍入取整的实数。

2、 int函数是不进行四舍五入，直接去掉小数部分取整。

3、int函数处理负数的小数时总是向上进位的。

标准规定int的最小取值范围是 -32767 到 32767。

int的取值范围因机器而异，但是一定要大于或者等于 -32767 到 32767。一般来说，int占用一个字的内存空间。因此，字长为 16 位（Bit）的旧式 IBM 兼容机使用 16 位来储存整型int，取值范围是-32768 到 32767 。

目前的个人电脑一般都是 32 位字长的，这些电脑中，int一般也是 32 位的，取值范围是 -2147483648 到 2147483647。对于使用 64 位 CPU 的电脑，使用更多位储存int也是很自然的事情，取值范围当然也会更大。

参考资料：百度百科-INT

参考技术A

作为函数，INT函数指数据库中常用函数中的“向下取整函数”。常用来取一个数中的整数部分。Int是将一个数值向下取整为最接近的整数的函数。为取整函数。

意思是将被转换数直接截取整数部分，不进行四舍五入运算。例如：

int(123.456);//取值为123

int(-123.456);//取值为124

int(1234.56);//取值为1234

扩展资料：

除int外，其他强制转换有：

void：声明函数无返回值或无参数，声明无类型指针，显示丢弃运算结果。（C89标准新增）

char：字符型类型数据，属于整型数据的一种。（K&R时期引入）

int：整型数据，表示范围通常为编译器指定的内存字节长。（K&R时期引入）

float：单精度浮点型数据，属于浮点数据的一种。（K&R时期引入）

double：双精度浮点型数据，属于浮点数据的一种。（K&R时期引入）

_Bool:布尔型（C99标准新增）

_Complex:复数的基本类型（C99标准新增）

_Imaginary:虚数，与复数基本类型相似，没有实部的纯虚数（C99标准新增）

_Generic:提供重载的接口入口（C11标准新增）

修饰关键字：

short：修饰int，短整型数据，可省略被修饰的int。（K&R时期引入）

long：修饰int，长整型数据，可省略被修饰的int。（K&R时期引入）

long long：修饰int，超长整型数据，可省略被修饰的int。（C99标准新增）

signed：修饰整型数据，有符号数据类型。（C89标准新增）

unsigned：修饰整型数据，无符号数据类型。（K&R时期引入）

restrict:用于限定和约束指针，并表明指针是访问一个数据对象的唯一且初始的方式。（C99标准新增）

参考资料：c语言_百度百科

参考技术B 不是的。
c语言的int型的强制类型转换是截尾取整的。
即int x=(int)3.997;
x的值是3。 参考技术C 不会四舍五入，会直接截断取整数部分。本回答被提问者采纳 参考技术D 有四舍五入的情况，在你想要保留几位小数的时候，多余的紧接着的一位要四舍五入
不过C里面没有提供四舍五入的函数，不过你可以这样
a = (int)(a*100 + 0.5)/100
这只是一个小技巧，对a的第三位进行四舍五入
比如将55.3351保留2位小数，第三位四舍五入，可以用
a=(a*100+0.5)/100.0或a=(int)(a*100+0.5)/100.0,,,我的问题是，，两个都行吗？有什么区别，我做过实验，貌似没什么区别……追问

是一样的，都是实型啊，第二个式子一个是整形，一个是实型，结果是实型啊

python数据类型强制转换和运算符

　# Number 强制类型转换

　　 (1) int 强制类型转换整型

　　 将浮点型数据强制转换成整型，它会默认将小数点后的数值舍去，不存在四舍五入
　　 将布尔值强制转换成整型，它会默认将True和False的值转变为1和0
　　 复数不能强制转化成整型，它会报错
　　 字符串能够强制转化为整型，但首先字符串必须是全数字，否则不行，会报错

　　 int只能对   int   float   bool   str(必须是全数字) 进行转换

　　# (1) float 强制转换为浮点型

　　 将整型强制转化为浮点型，它会默认在整型之后面加上小数点.0
　　 将布尔值强制转化为浮点型，它会默认将Ture和False的值转化为1.0和0.0
　　 复数不能转化为浮点型，它会报错
　　 字符串能够强制转化为浮点型，但首先字符串必须是全数字，否则不行，会报错

　　# (3) complex 强制转化为复数

　　 将整型强制转化为复数，它会默认在整型后面加上 0j
　　 将浮点型强制转换为复数，同上
　　 将布尔值强制转化为复数，它会将True转化为 1+0j，False转化为 0j
　　 将字符串强制转化为复数，但首先字符串必须是全数字，否则不行，会报错

　　# (4) bool 强制转化为布尔类型 结果只有两种 要么True 要么False

　　# bool 可以转换所有的数据类型均为True

　　# 唯独有以下十种情况 会为False   0   0.0    0j   False   ‘‘空   ()空元祖     []空列表    set()空集合    None

　　# None 系统关键字 无特殊意义 代表啥也没有一般用于初始化变量的时候用

 

 

　# 容器类型强制转换 (str list tuple set dict) 只能相互转换，不能转换Number数据类型

　　    (1) str 所有数据类型都可以强制转化成字符串str
　　  　　　　规律：   在原有类型基础上，在外套一层引号即可
　　  　　　　repr 　　打印出字符串类型的那个引号(原型化输出)

 　　   (2) list 所有数据类型都可以强制转化为列表list
   　　　　　　规律：强制转换：如果是字符串，把字符串当中的每一个字符当成列表
 　　　　　　　　　  中的新元素，其它都是在原有数据类型上，在外面套一个[]即可

 　　　　　　将字符串强制转化为列表时，它会在外套一层  []  同时里面的字符也会一一显示出字符串的引号
 　　　　　　将字典强制转化为列表型时，它会在外套一层  []  同时只保留字典里的键，而忽略字典里的值

　　    (3) tuple 所有数据类型都可以强制转化为元组tuple
　　   　　　　规律：强制转换：如果是字符串，把字符串当中的每一个字符当成列表
　　 　　　　             中的新元素，其它都是在原有数据类型上，在外面套一个 () 即可

　　 　　　　  将字典强制转化为元组时，它会在外套一层  ()  同时只保留字典里的键，而忽略字典里的值

           (4) set 所有数据类型都可以强制转化为集合set
        　　　　  规律：强制转换：如果是字符串，把字符串当中的每一个字符当成列表
 　　　　　　　　     中的新元素，(列表中的字符串会无序排列，因为集合本是无序排列)
 　　　　　　　　     其它都是在原有数据类型上，在外面套一个  {}  即可

　　　　  # 将字典强制转化为集合时，它会在外套一层{}同时只保留字典里的键，而忽略字典里的值

 

　　　(5) dict 强制转化为字典类型

　　　# 多级容器数据: 该类型是容器数据，并且里面的元素还是容器类型数据

　　　# ## 二级容器

　　　# 二级列表
　　　　listvar = [1,2,3,4,5[6,7,8,9]]

　　　# 二级元组
　　　　tuplevar = (1,2,3,4,5(6,7,8,9))

　　　# 二级集合 (只能在里面放元组作为集合里面的容器数据,只能放可哈希不可变的数据)
　　　　setvar = {1,2,3,(4,5,6)}

　　　# 二级字典
　　　　dictvar = {‘a‘:{‘c‘:3},‘b‘:2}

　　　# 四级容器

　　　　content = [1,2,3,4,(4,6,{‘a‘:{4,5,6,7,8},‘b‘:2},7),5]

　　　# 等长的二级容器

　　　　‘‘‘
　　　　首先容器是两个，代表二级容器
　　　　每一个容器元素个数都是一样的叫做等长
　　　　‘‘‘
　　　　listvar = [(1,2,3,4),(5,6,7,8)]
　　　　tupvar = ([1,2],[3,4],[5,6])

　　　# ## dict 强制转换成字典: (里面的元素只能是两个)

　　　# (1) 外面是列表，里面是 列表、元组、字符串(元素个数只能是两个，否则会报错)
　　　　listvar = [[‘a‘,1],(‘b‘,2)]

　　　# (2) 外面是元组，里面是列表、元组、字符串
　　　　tupvar = ([‘c‘,3],(‘d‘,33))

　　　# (3) 外面是集合，里面是元组、字符串

　　　　setvar ={(‘a‘,1),(‘b‘,2)}

 

　　　# 总结:
　　　　‘‘‘
　　　　容器类型数据强转：
　　　　str()   tuple()   list()   set()   dict() 都能转换成对应的数据类型
　　　　Number数据类型强转：
　　　　int()   float()   bool()    complex() 都能转换成对应的数据类型

　　　　可以强转函数值进行初始化
　　　　‘‘‘

 

 

 

　# 变量存储的缓存机制 (为了节省空间)

　　# (1)Number (int float bool complex)

　　# int (整型类取值在-5~正无穷范围内，取两个相同的值，
　　# 这两个值得地址就相同，若超过这个取值范围，地址就不同)

　　# float (浮点型取值只要是非负数，值得地址就相同)

　　# bool (在布尔值相同的情况下，值得地址相同)

　　# complex (在实数加虚数的情况下，永远不一样，只有虚数的情况下，就会一样)

 

　　# (2)容器类型数据 (str list tuple set dict)

　　# str (字符串值相同情况下，值得地址是一样的)
　　# list   tuple   set   dict (无论啥情况，值得地址都不一样)
　　# 例外： (空元祖的值得地址是一样的)

 

　　# # python 运算符

　　# (1) 算数运算符： + - * / //地板除 %取余 **幂运算

　　#    /  (除法,结果一定是小数)
　　#   //  地板除(整除) (如果相除的两个含有小数，那么就在结果上加上.0)

　　var1 = -7
　　var2 = 4
　　res = var1 % var2
　　print(res) => 1
　　# 把-7的负号拿走，然后7 - 4 = 3
　　# 算出结果，再把负号拿回来变成-3
　　# 这时在与4相加，-3 + 4 = 1
　　# 就可求得整除的结果

　　var1 = 7
　　varl = -4
　　res = var1 % var2
　　print(res) => -1

　　# 跟上述同理，先7 - 4 = 3
　　# 然后再用3 + (-4)
　　# 就可求得整除的结果

 

 

 

　# ## 比较运算符   >    <    >=    <=    ==等于    !=不等于

　　# 比较运算符就只有两种结果，要么是True 要么是False

　　‘‘‘
　　是两个等号，不是一个等号，1个等号是在做变量的赋值，两个是比较是否相同
　　‘‘‘

 

 

　　# ### 身份运算符 is 和 is not (检测两个数据在内存中是否是同一个值)

　　var1 = 5
　　varl = 6
　　print(id(var1),id(var2))

　　# is 用来判断两个变量的地址是否一致
　　res = var1 is var2
　　print(res) => True

　　res = var1 is not var2
　　print(res) => False

　　# var1 == var2 与 var1 is var2 的区别
　　‘‘‘
　　一个是比较两个值是否相同
　　一个是比较两个值的地址是否相同
　　‘‘‘

 

　# ### 逻辑运算符 and or not

　　# and 与
　　‘‘‘全真则真,一假则假‘‘‘
　　res = True and True => True
　　res = True and False => False
　　res = False and True => False
　　res = False and False => False
　　print(res)


　　# or 或
　　‘‘‘全真则真,全假则假,(一假一真,一真一假 => 都为真)‘‘‘
　　res = True or True => True
　　res = True or False => True
　　res = False or True => True
　　res = False or False => False
　　print(res)

 

　　# not 非
　　‘‘‘真变假,假变真‘‘‘
　　res = not False => True
　　res = not True => False

　# (1)逻辑短路 (后面代码不走了)
　　‘‘‘
　　# 两种情况
　　res = False and 布尔值 => False
　　res = True or 布尔值 => False
　　‘‘‘
　# print 默认返回一个 None 而None的布尔值是假

　　res = False and print(1) => False
　　print(res)
　　res = True and print(1) => 1 None
　　res = True or print(3) => True
　　res = False or print(4) => 4 None

 

　# 逻辑运算符优先级
　　‘‘‘()  >  not  >  and  >  or‘‘‘

　　res = 5 or 6 and 7
　　# 5 or 7 => 5
　　print(res)

　　res = (5 or 6) and 7
　　# 5 and 7 => 7

　　res = not (5 or 6) and 7

　　# (5 or 6) => 5
　　# not 5 => False
　　# False and 7 => False

　　res = 5>6 or 7<8 and 9>10 or 11<12
　　print(res) => True

　　‘‘‘
　　有一种情况不用考虑and和or优先级问题,
　　就是or短路 比如 True or ...... => 结果一定为 True
　　‘‘‘

 

　　# ## 数据类型的判断 isinstance
　　‘‘‘
　　isinstance(要判断的数据,判断的类型) 要么返回真，要么返回假
　　ininstance(要判断的数据,(元组，放上各种数据类型,满足一个条件即为真))
　　‘‘‘

　　# 5 是 int 类型的吗？
　　res = isinstance(5,int) => True
　　res = isinstance(‘123‘,list) => False
　　print(res)

　　# 有一个类型满足 反为真,一个都不满足,反为假
　　res = isinstance(5,(list,tuple,str,int))
　　print(res) => True
　　res = isinstance(5,(list,tuple,str,))
　　print(res) => False