मैं एक pid_t का अधिकतम मूल्य कैसे निर्धारित कर सकता हूं?

Question

मैं pid_t प्रकार का अधिकतम मूल्य कैसे निर्धारित कर सकता हूं? मेरे सिस्टम पर कोई PID_MAX निरंतर नहीं है।

(ध्यान दें, मैं डेटा प्रकार, नहीं द्वारा अनुमत अधिकतम मूल्य मतलब वास्तविक अधिकतम मूल्य प्रणाली प्रक्रियाओं के लिए आवंटित करेगा।)

उपयोग मामला: मैं एक उपयोगकर्ता- परिवर्तित कर रहा हूँ pid_t पर एक पिड की स्ट्रिंग विनिर्देश प्रदान किया गया है, और यह सुनिश्चित करना चाहता है कि उपयोगकर्ता का इनपुट प्रकार की क्षमता से अधिक न हो।

Answer 1

POSIX (2008) says:

blksize_t, pid_t, और ssize_t हस्ताक्षरित होगा पूर्णांक प्रकार के।

और:

कार्यान्वयन एक या अधिक प्रोग्रामिंग परिवेशों का समर्थन करेगा, जिसमें blksize_t, pid_t, size_t, ssize_t, और suseconds_t की चौड़ाई कोई प्रकार लंबे की चौड़ाई से अधिक है।

तो तुम long करने के लिए उपयोगकर्ता तार परिवर्तित कर सकते हैं और फिर long pid; .. pid == (pid_t)pid का उपयोग कर pid_t प्रकार के लिए अतिप्रवाह लिए जाँच करें।

Answer 2

अपने हेडर से एक में:

#ifndef PID_MAX 
#define PID_MAX INT_MAX // or whatever value you see fit 
#endif 

आप भी यह पर्यावरण चर के आधार पर सर्वर/ओएस निर्भर परिभाषा के आधार पर कर सकते हैं।

देखो: Similar post : Maximum PID in Linux

Answer 3

क्या मैं अतीत में कभी कभी किया है एक बड़ा डेटा प्रकार प्रयोग किया जाता है, और फिर जब मैं अपने छोटे प्रकार में बदलने का, तुरंत बड़े प्रकार पर वापस परिवर्तित करें और जांचें कि मूल्य नहीं बदला

उदाहरण के लिए, मान लीजिए कि आप एक int64_t बजाय प्रयोग किया है, तो आप की तरह कुछ हो सकता है:

int64_t my_pid64; 

/* ... parse string value into my_pid64 ... */ 

pid_t my_pid = (pid_t) my_pid64; 
if ((int64_t) my_pid != my_pid64) /* check that value was not out of range of pid_t */ 
{ 
    /* ... handle error ... */ 
} 

वहाँ उपयोग करने के लिए बड़े डेटा प्रकार के लिए कोई बढ़िया विकल्प है। "लंबा" सबसे बड़ा आदिम पूर्णांक डेटा प्रकार होता था लेकिन यह कुछ सामान्य कंपाइलरों/आर्किटेक्चर पर अब सत्य नहीं है - यहां तक ​​कि लिनक्स के लिए भी (नीचे टिप्पणियां देखें)। इस बीच, intmax_t प्रकार में खराब लाइब्रेरी समर्थन है। नतीजा यह है कि int64_t कभी-कभी अभ्यास में अधिक उपयोगी होता है।

लेकिन, मूल रूप से बड़े डेटा प्रकार के लिए आपके विकल्प शायद लंबे, int64_t और intmax_t हैं।

Answer 4

स्टीवन का जवाब एक अच्छा दृष्टिकोण है।

यदि आपको वास्तव में अपरिभाषित व्यवहार पर निर्भर रहे बिना अधिकतम pid_t मूल्य निर्धारित करना चाहते हैं, मुझे लगता है कि आपका सर्वश्रेष्ठ दांव है:

#include <sys/types.h> 
#include <limits.h> 
#include <stdlib.h> 

static inline pid_t get_max_pid_t() 
{ 
    if (sizeof(pid_t) == sizeof(short)) return SHRT_MAX; 
    if (sizeof(pid_t) == sizeof(int)) return INT_MAX; 
    if (sizeof(pid_t) == sizeof(long)) return LONG_MAX; 
#if defined(LLONG_MAX) // C99 
    if (sizeof(pid_t) == sizeof(long long)) return LLONG_MAX; 
#endif 
    abort(); 
} 

POSIX गारंटी देता है कि pid_t एक हस्ताक्षरित अभिन्न प्रकार है। यह कोड मानता है कि एक हस्ताक्षरित अभिन्न प्रकार का आकार विशिष्ट रूप से उस प्रकार को निर्धारित करता है।मुझे लगता है कि यह एक उत्कृष्ट धारणा है, लेकिन मुझे यकीन नहीं है कि मानक इसकी गारंटी देता है या नहीं।

कोई सभ्य कंपाइलर इन सभी को गैर-अस्तित्व में इनलाइन और निरंतर प्रसारित करेगा, इसलिए प्रदर्शन चिंता का विषय नहीं है।

(एक तरफ: C++ में आप std::numeric_limits<pid_t>::max() लिखते थे और इसके साथ किया जा।)