का उपयोग दौर() ग

Question

में समारोह मैं थोड़ा सी में round() समारोह

सबसे पहले लेकर संदेह में हूँ, आदमी कहते हैं:

SYNOPSIS 
    #include <math.h> 
    double round(double x); 

RETURN VALUE 
    These functions return the rounded integer value. 
    If x is integral, +0, -0, NaN, or infinite, x itself is returned. 

वापसी मान एक double/float या है एक int?

दूसरे स्थान पर, मैंने एक ऐसा फ़ंक्शन बनाया है जो पहले राउंड करता है, फिर int में रहता है। मेरे कोड मैं लिए एक मतलब के रूप में उपयोग पर लैटर युगल

int tointn(double in,int n) 
{ 
    int i = 0; 
    i = (int)round(in*pow(10,n)); 
    return i; 
} 

इस समारोह की तुलना जाहिरा तौर पर मेरे परीक्षण के दौरान स्थिर नहीं है। क्या यहां अनावश्यकता है? खैर ... मैं केवल एक जवाब के लिए नहीं देख रहा हूं, लेकिन इस विषय पर एक बेहतर समझ है।

Answer 1

मैन-पेज में शब्द का अर्थ शाब्दिक रूप से पढ़ना है, जो कि इसके गणितीय अर्थ में है। शब्द "एक्स अभिन्न" का अर्थ है कि xZ का एक तत्व है, x में डेटा प्रकार int है।

कास्टिंग एक doubleint लिए खतरनाक हो सकता है क्योंकि अधिकतम मनमाना अभिन्न मूल्य एक double धारण कर सकते हैं 2^52, अधिकतम मूल्य एक int धारण कर सकते हैं छोटे हो सकता है (आईईईई 754 अनुरूप binary64 कल्पना करते हुए) है (यह ज्यादातर 32 है 32-बिट आर्किटेक्चर पर बिट और कुछ 64-बिट आर्किटेक्चर पर 32-बिट)।

आप दस में से केवल शक्तियों की जरूरत है कि आप इस छोटे कार्यक्रम खुद के साथ यह परीक्षण कर सकते हैं:

#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 

int main(){ 
    int i; 
    for(i = 0;i < 26;i++){ 
    printf("%d:\t%.2f\t%d\n",i, pow(10,i), (int)pow(10,i)); 
    } 
    exit(EXIT_SUCCESS); 
} 

इसके बजाय कास्टिंग आप कार्यों कि e.g तरह .: lround(3) एक उचित अभिन्न डेटा प्रकार वापसी का उपयोग करना चाहिए की

।

Answer 2

यहां मैन पेज से एक अंश है।

#include <math.h> 

    double round(double x); 
    float roundf(float x); 
    long double roundl(long double x); 

नोटिस: लौटाया मूल्य कभी पूर्णांक नहीं होता है। हालांकि, लौटाए गए मान का आंशिक भाग 0

नोटिस पर सेट किया गया है: सटीक फ़ंक्शन के आधार पर लौटाए गए मूल्य का प्रकार निर्धारित करेगा।

These functions round x to the nearest integer, but round halfway cases 
    away from zero (regardless of the current rounding direction, see 
    fenv(3)), instead of to the nearest even integer like rint(3). 

    For example, round(0.5) is 1.0, and round(-0.5) is -1.0.