2. 程式人生 > >c++四捨五入函式，向上取整，向下取整函式

c++四捨五入函式，向上取整，向下取整函式

阿新 • • 發佈：2019-01-09

對含有小數點的數進行四捨五入是比較普遍的一種需求。在C++中也有類似的取整函式。在C++的標頭檔案中有floor()和ceil()函式。在STL中還有round()函式。這三個函式的作用如下：

函式名稱 函式說明 2.1 2.9 -2.1 -2.9
Floor() 不大於自變數的最大整數 2 2 -3 -3
Ceil() 不小於自變數的最大整數 3 3 -2 -2
Round() 四捨五入到最鄰近的整數 2 3 -2 -3

從函式說明中可以看出，
（1） Floor()會取不大於自變數的最大整數，這樣自變數是3.1或3.9是沒有區別的，返回都是3；自變數是-2.1或-2.9也是沒有區別的，返回都是-3；
（2） Ceil()會取不小於自變數的最大整數，這樣自變數是3.1或3.9，返回都是4；自變數是-2.1或-2.9，返回的都是-2；
（3） Round()函式，才是我們需要的四捨五入的函式，因為它會返回離自變數最近的整數，這個返回的整數可能大於也可能小於原來的數，但是一定是離它最近的那個整數。

double floor (double x);
      float floor (float x);
long double floor (long double x);
     double floor (T x);           // additional overloads for integral types

1
2
3
4
5
6
7
8
9
10
11
12

/* floor example */
#include <stdio.h>      /* printf */
#include <math.h>       /* floor */

int
 
 main ()
{
  printf ( "floor of 2.3 is %.1lf\n", floor (2.3) );
  printf ( "floor of 3.8 is %.1lf\n", floor (3.8) );
  printf ( "floor of -2.3 is %.1lf\n", floor (-2.3) );
  printf ( "floor of -3.8 is %.1lf\n", floor (-3.8) );
  return 0;
}

Output:

floor of 2.3 is 2.0
floor of 3.8 is 3.0
floor of -2.3 is -3.0
floor of -3.8 is -4.0

 
double ceil (double x);
      float ceil (float x);
long double ceil (long double x);
     double ceil (T x);           // additional overloads for integral types
1
2
3
4
5
6
7
8
9
10
11
12

/* ceil example */
#include <stdio.h>      /* printf */
#include <math.h>       /* ceil */

int main ()
{
  printf ( "ceil of 2.3 is %.1f\n", ceil(2.3) );
  printf ( "ceil of 3.8 is %.1f\n", ceil(3.8) );
  printf ( "ceil of -2.3 is %.1f\n", ceil(-2.3) );
  printf ( "ceil of -3.8 is %.1f\n", ceil(-3.8) );
  return 0;
}

Output:

ceil of 2.3 is 3.0
ceil of 3.8 is 4.0
ceil of -2.3 is -2.0
ceil of -3.8 is -3.0

 double round (double x);
      float round (float x);
long double round (long double x);
     double round (T x);           // additional overloads for integral types
/* round vs floor vs ceil vs trunc */
#include <stdio.h>      /* printf */
#include <math.h>       /* round, floor, ceil, trunc */

int main ()
{
  const char * format = "%.1f \t%.1f \t%.1f \t%.1f \t%.1f\n";
  printf ("value\tround\tfloor\tceil\ttrunc\n");
  printf ("-----\t-----\t-----\t----\t-----\n");
  printf (format, 2.3,round( 2.3),floor( 2.3),ceil( 2.3),trunc( 2.3));
  printf (format, 3.8,round( 3.8),floor( 3.8),ceil( 3.8),trunc( 3.8));
  printf (format, 5.5,round( 5.5),floor( 5.5),ceil( 5.5),trunc( 5.5));
  printf (format,-2.3,round(-2.3),floor(-2.3),ceil(-2.3),trunc(-2.3));
  printf (format,-3.8,round(-3.8),floor(-3.8),ceil(-3.8),trunc(-3.8));
  printf (format,-5.5,round(-5.5),floor(-5.5),ceil(-5.5),trunc(-5.5));
  return 0;
}


Output:

value   round   floor   ceil    trunc
-----   -----   -----   ----    -----
2.3     2.0     2.0     3.0     2.0
3.8     4.0     3.0     4.0     3.0
5.5     6.0     5.0     6.0     5.0
-2.3    -2.0    -3.0    -2.0    -2.0
-3.8    -4.0    -4.0    -3.0    -3.0
-5.5    -6.0    -6.0    -5.0    -5.0
具體可檢視文獻：http://www.cplusplus.com/reference/cmath/round/

相關推薦

PHP取整，四捨五入取整、向上取整、向下取整、小數擷取

PHP取整數函式常用的四種方法： 1.直接取整，捨棄小數，保留整數：intval()；  2.四捨五入取整：round()；  3.向上取整，有小數就加1：ceil()；  4.向下取整：floor()。 一、intval—對變數轉成整數型態  int

PHP取整，四舍五入取整、向上取整、向下取整、小數截取

取整 根據 四舍五入 span 四種方法 負數 round 向下取整 5.6 PHP取整數函數常用的四種方法： 1.直接取整，舍棄小數，保留整數：intval()； 2.四舍五入取整：round()； 3.向上取整，有小數就加1：ceil()； 4.向下取整：floor()

C/C++去小數位取整、向下取整、向上取整與四捨五入

簡單整理一下這四種取整處理方法~ 去小數位取整 （直接截去小數點後的資料） 型別轉換 （浮點型→整型） 當浮點型轉換為整型時，會截去小數點之後的資料，僅保留整數位。 double x=2.3; int y=x; cout<<y; 輸出

C語言基礎： 浮點數轉化整數（向上取整、向下取整）| 求絕對值函式

Objective-C拓展了C,自然很多用法是和C一致的。比如浮點數轉化成整數，就有以下四種情況。  1.簡單粗暴，直接轉化 float f = 1.5; int a;a = (int)f; NSLog("a = %d",a); 輸出結果是1。（int）是強制型別轉化，丟棄浮點數的小數部分。

向上取整、向下取整以及四捨五入、取整、取餘、取小數

一、 向上取整 import math num = 10.5 math.ceil(num) #輸出結果：11.0 (浮點型) 二、 向下取整 int(10.5) #輸出結果：10 （整數型） import math num = 10.5 math.floor(num)

四捨五入round,近一法取整（向上取整)ceil,捨去發取整（向下取整）floor

1.round 例子:round('字串變數','精度','模式(php5.3引入)') <?php echo round(3.4); // 3 echo round(3.5)

向上取整；向下取整；四捨五入

REPORT z_zcd_013. DATA:a TYPE mseg-menge,      b TYPE mseg-menge,      c TYPE mseg-menge. a = '1.36'. b = '1.34'. c = a / b. WRITE:/,c. "輸

Python取整——向上取整、向下取整、四捨五入取整、向0取整

廢話少敘，直接上code： 首先，不得不提醒大家一個容易被忽視或者搞混的問題——一般的，0.5這種末尾是5的小數，四捨五入取整應進位。這個進位的意思是：-0.5 → -1；0.5 → 1.即正負情況不同，都向著遠離0，使得絕對值更大的方向進位 向上取整：math.ceil() impo

Sql Server 裡的向上取整、向下取整、四捨五入取整的例項！

==================================================== 【四捨五入取整擷取】 select round(54.56,0) ===================================================

向上取整和向下取整（ceil round）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Swift Double向上取整和向下取整、Double轉Int/String

floor()函式：向下取整，取小於等於這個數的最大整數 (floor(3.94) = 3) ceil()函式：向上取整，取大於等於這個數的最小整數 (ceil(3.14) = 4) import Foundation extension Double { func int

向上取整和向下取整

C語言有以下幾種取整方法： 1、直接賦值給整數變數。如： int i = 2.5; 或 i = (int) 2.5; 這種方法採用的是捨去小數部分 2、C/C++中的整數除法運算子“/”本身就有取整功能(int / int)，但是整數除法對負數的取整結果和使用的C編

qt ceil向上取整floor向下取整

double a = 11.2; double b = 11.5; double c = -11.2; double d = -11.5; qDebug()<<" "<&l

關於js開發中保留小數位計算函數（以向上取整或向下取整的方式保留小數）

判斷 開發 func 小數 前端 直接 小數位數 rst 使用 前端工作中經常遇到數字計算保留小數問題，由於不是四舍五入的方式不能使用toFixed函數，本文采用正則表達式匹配字符串的方式，解決對數字的向上或向下保留小數問題： 1、向上保留小數（只要目標小數位後有有效數字

c++四捨五入函式，向上取整，向下取整函式

對含有小數點的數進行四捨五入是比較普遍的一種需求。在C++中也有類似的取整函式。在C++的標頭檔案中有floor()和ceil()函式。在STL中還有round()函式。這三個函式的作用如下： 函式名稱 函式說明 2.1 2.9 -2.1 -2.9 Floor() 不大於自

c# 小數四捨五入，向上取整，向下取整，見角進元保留多個小數位數

/// <summary> /// 實現資料的四捨五入法 /// </summary> /// <param name="v">要進行處理的資料</param> /// <param n

C/C++ 取整函式ceil(),floor()，向上取整，向下取整

#include <math.h> double floor(double x); float floorf(float x); long double floorl(long double x); double floor(double x); double ceil(double x

C#中取整，向上取，向下取

log () ceil 取整 mat math 示例 floor 向下取整 Math.Ceiling()向上取整，Math.Floor()向下取整 示例： d = 4.56789 string res = Math.Ceiling(Convert.ToDecimal(d))

（轉）C/C++ 取整函數ceil(),floor()，向上取整，向下取整

ceil 最小整數 1.2 ria 使用 整數 html follow line 轉自： C/C++ 取整函數ceil(),floor() C/C++ 取整函數ceil(),floor() #include <math.h> double flo

java數字（double/float）向上取整，向下取整，四捨五入

向上取整：Math.ceil(double a)  向下取整：Math.floor(double a)  四捨五入取整：Math.round(double a)  例： Math.ceil（24.1）--> 25 Math.floor（24.8）--&