(प्रकार) मान और प्रकार (मान) के बीच क्या अंतर है?

Question

क्या सी ++ में

(type)value 

और

type(value) 

के बीच का अंतर है?

Answer 1

कोई फर्क नहीं पड़ता; मानक (§5.2.3):

एक सरल प्रकार-विनिर्देशक (7.1.5) एक संश्लेषित अभिव्यक्ति-सूची के बाद अभिव्यक्ति सूची दिए गए निर्दिष्ट प्रकार का मान बनाता है। यदि अभिव्यक्ति सूची एक एकल अभिव्यक्ति है, तो टाइप रूपांतरण अभिव्यक्ति समतुल्य (अभिव्यक्ति में, और अर्थ में परिभाषित होने पर) समान कास्ट अभिव्यक्ति (5.4) के बराबर है।

चूंकि प्रश्न type(value) और (type)value के बीच अंतर निर्दिष्ट करता है, तो बिल्कुल कोई अंतर नहीं है।

यदि और यदि आप अल्पविराम से अलग सूची सूची से संबंधित हैं तो केवल तभी अंतर हो सकता है। इस मामले में:

यदि अभिव्यक्ति सूची एक से अधिक मान निर्दिष्ट करती है, तो प्रकार एक उपयुक्त घोषित कन्स्ट्रक्टर (8.5, 12.1) के साथ एक वर्ग होगा, और अभिव्यक्ति टी (x1, x2, ...) घोषणा टी टी (x1, x2, ...) के प्रभाव में बराबर है; कुछ आविष्कारित अस्थायी परिवर्तनीय टी के लिए, परिणामस्वरूप टी का मूल्य एक रावल्यू के रूप में होता है।

जैसा कि ट्राउबाडॉर ने बताया, वहां कुछ प्रकार के नाम हैं जिनके लिए type(value) संस्करण बस संकलित नहीं होगा। उदाहरण के लिए:

char *a = (char *)string; 

संकलन होगा, लेकिन:

char *a = char *(string); 

नहीं होगा। एक अलग नाम के साथ एक ही प्रकार (जैसे, एक typedef के साथ बनाया) हालांकि काम कर सकते हैं:

typedef char *char_ptr; 

char *a = char_ptr(string); 

Answer 2

वहाँ कोई अंतर नहीं है; सी ++ मानक (1998 और 2003 संस्करण) इस बिंदु के बारे में स्पष्ट है। निम्न प्रोग्राम आज़माएं, सुनिश्चित करें कि आप एक कंपाइलर का उपयोग करें जो अनुपालनशील है, जैसे http://comeaucomputing.com/tryitout/ पर निःशुल्क पूर्वावलोकन।

#include <cstdlib> 
#include <string> 
int main() { 
    int('A'); (int) 'A'; // obvious 
    (std::string) "abc"; // not so obvious 
    unsigned(a_var) = 3; // see note below 
    (long const&) a_var; // const or refs, which T(v) can't do 
    return EXIT_SUCCESS; 
} 

नोट: unsigned(a_var) अलग है, लेकिन एक तरह से उन सटीक टोकन कुछ और मतलब हो सकता है दिखाने करता है। यह हस्ताक्षर किए गए प्रकार के a_var नामक एक चर घोषित कर रहा है, और बिल्कुल एक कलाकार नहीं है। (आप कार्य या सरणियों की ओर इशारा के साथ परिचित हैं, तो विचार करें कि कैसे आप void (*pf)() या int (*pa)[42] की तरह एक प्रकार में p के चारों ओर एक कोष्ठक का उपयोग करने के लिए है।)

(चेतावनी उत्पादित कर रहे हैं के बाद से इन बयानों मूल्य का उपयोग नहीं करते और एक वास्तविक कार्यक्रम में जो लगभग निश्चित रूप से एक त्रुटि होगी, लेकिन सबकुछ अभी भी काम करता है। मेरे पास सब कुछ लाइन बनाने के बाद इसे बदलने का दिल नहीं था।)

Answer 3

दोनों में कोई अंतर नहीं है, लेकिन दोनों कभी-कभी 'प्रकार (मान)' एक कास्ट नहीं है।

यहां मानक मसौदा N3242, खंड 8.2.1 से एक उदाहरण है:

struct S 
{ 
    S(int); 
}; 

void foo(double a) 
{ 
    S w(int(a)); // function declaration 
    S y((int)a); // object declaration 
} 

इस मामले में 'पूर्णांक (क)' एक डाली क्योंकि 'एक' एक मूल्य नहीं है नहीं है, यह एक पैरामीटर है अनावश्यक कोष्ठक से घिरा नाम। दस्तावेज़ में कहा गया है

अस्पष्टता एक समारोह शैली कास्ट और एक घोषणा 6.8 में उल्लेख भी एक घोषणा के संदर्भ में हो सकता है के बीच समानता से उत्पन्न होने वाली। उस संदर्भ में, विकल्प पैरामीटर नाम के चारों ओर कोष्ठक के अनावश्यक सेट के साथ घोषणा और प्रारंभकर्ता के रूप में फ़ंक्शन-स्टाइल कास्ट के साथ ऑब्जेक्ट घोषणा के बीच एक फ़ंक्शन के बीच है। 6.8 में उल्लिखित अस्पष्टताओं के लिए, रिज़ॉल्यूशन किसी भी निर्माण पर विचार करना है जो संभवतः घोषणा घोषित कर सकता है।

Answer 4

ग में वहाँ, कोई type (value) है, जबकि सी में/C++ दोनों type (value) और (type) value अनुमति दी जाती है।

Answer 5

सी में अपने विकल्पों को समझने के लिए ++ (केवल एक एक सुरक्षा जांच है)

#include<boost/numeric/conversion/cast.hpp> 

using std::cout; 
using std::endl; 
int main(){ 

    float smallf = 100.1; 

    cout << (int)smallf << endl; // outputs 100 // c cast 
    cout << int(smallf) << endl; // outputs 100 // c++ constructor = c cast 

    cout << static_cast<int>(smallf) << endl; // outputs 100 
// cout << static_cast<int&>(smallf) << endl; // not allowed 
    cout << reinterpret_cast<int&>(smallf) << endl; // outputs 1120416563 
    cout << boost::numeric_cast<int>(smallf) << endl; // outputs 100 

    float bigf = 1.23e12; 

    cout << (int)bigf << endl; // outputs -2147483648 
    cout << int(bigf) << endl; // outputs -2147483648 

    cout << static_cast<int>(bigf) << endl; // outputs -2147483648 
// cout << static_cast<int&>(bigf) << endl; // not allowed 
    cout << reinterpret_cast<int&>(bigf) << endl; // outputs 1401893083 
    cout << boost::numeric_cast<int>(bigf) << endl; // throws bad numeric conversion 
}