मूल्यों की सीमित सीमा के साथ सी में परिवर्तनीय

Question

मेरे पास सी में एक चर कैसे हो सकता है जिसका मूल्य केवल 20 से 520 के बीच होना चाहिए? मैं उस चर असाइनमेंट को 20 से 520 के बीच मानों तक सीमित करना चाहता हूं? यदि मैं एक एनम लेता हूं जिसका मूल्य 20 से शुरू होगा, तो मुझे अभी भी enum के अंदर एक और 51 9 मूल्यों को परिभाषित करने की आवश्यकता है।

Answer 1

वैसे आप एक तरह से कर सकते हैं:

typedef enum { 
    F_FIRST = 20, 
    E_LAST = 520 
} MySpecialEnum; 

हालांकि इस सीमा लागू नहीं किया जाएगा, या तो संकलन समय पर या रन-टाइम में है, लेकिन आप स्पष्ट सीमा-जांच के लिए उपयोग कर सकते हैं, और एक के रूप में स्वयं दस्तावेज कोड में सहायता।

---

याद रखें यह सी, निम्न स्तर की भाषा है। आप रन-टाइम उपयोगकर्ता परिभाषित सीमाओं के साथ चर की जाँच चाहते हैं तो इस तरह के पास्कल, के रूप में एक भाषा है जहाँ आप इस तरह चर एक subrange घोषणा कर सकते हैं पर विचार करें:

PROGRAM test; 

VAR 
    x : 20 .. 520; 

BEGIN 
    x := 20; // OK 
    x := 1000; // error 
END. 

और फिर आप रन पर सीमा की जाँच मिल बिना किसी स्पष्ट कोड के। बेशक इसका प्रदर्शन जुर्माना है।

Answer 2

मेरे पास सी में एक चर कैसे हो सकता है जिसका मूल्य केवल 20 से 520 के बीच होना चाहिए?

वहाँ सी में इस तरह के एक डेटा प्रकार

यहां तक ​​कि अगर सीमा कुछ, कुछ प्रकार की सीमा के करीब underflowing के खतरे या बह निकला अभी भी होगा एक बात हो गया था (सोच भी नहीं है उदाहरण के लिए unsigned int, जहां आप निचले बाउंड 0 होना चाहते हैं, लेकिन कोई भी उस बाध्य हो सकता है)।

---

क्या आप हालांकि ऐसा कर सकते हैं प्राप्त करने के लिए अपनी खुद की संरचनाओं, accessors और/या enum (रों) लिखने के लिए है। यदि आप रुचि रखते हैं तो पॉल आर के जवाब को पढ़ें। हालांकि मैं आपको ऐसा करने के लिए प्रोत्साहित नहीं करता हूं।

मैं यह कर होता है, अगर उदाहरण के लिए चर उपयोगकर्ता द्वारा भरा जाना था:

int v; 
do { 
    scanf("%d", &v); 
} while(!(v >= 20 && v <= 520)); 

ताकि उपयोगकर्ता बार-बार प्रेरित किया जाएगा, जब तक उसकी इनपुट मानदंड से मेल खाते।

---

पुनश्च: यह एक XY सवाल की तरह लगता है।

Answer 3

सी के पास सीधे कोई तरीका नहीं है जो आप चाहते हैं व्यक्त करें। ध्यान दें कि enum मान्य मान लागू नहीं करता है। आप enum के अंतर्निहित प्रकार के मान को असाइन कर सकते हैं।

आप हमेशा अपने तर्क के साथ आ सकते हैं, उदा। यदि यह किसी ऑब्जेक्ट का हिस्सा है जिसे आप संरचना के रूप में मॉडल करते हैं:

struct foo 
{ 
    unsigned bar; 
}; 

// [...] 

int foo_setBar(struct foo *self, unsigned val) 
{ 
    if (val < 20 || val > 520) return -1; 
    self->bar = val; 
    return 0; 
} 

Answer 4

दुर्भाग्यवश, सी संरचना सदस्यों को अभिगम नियंत्रण प्रदान नहीं करता है। पहले बहुत बुरा भाग्य।

आपको करना है (कोशिश करें?) किसी भी उपयुक्त तरीके से इस सीमा के आसपास काम करते हैं। एक उपयोगकर्ता से डेटा दूर छिपा हो सकता है:

type.h:

#include <stdbool.h> 

struct TheType; 
typedef struct TheType TheType; 

unsigned short get(TheType const* type); 
bool set(TheType* type, unsigned short value); 

type.c:

struct TheType 
{ 
    unsigned short value; 
} 

unsigned short get(TheType const* type) 
{ 
    return type->value; 
} 

bool set(TheType* type, unsigned short value) 
{ 
    if(value < 20 || value > 520) 
     return false; 
    type->value = value; 
    return true; 
} 

यह, हालांकि एक और दोष यह है के साथ आता है, इस तरह के रूप में अन्य सुविधाओं के रूप में sizeof अनुपयोगी भी हो सकता है ... हमें शायद कम से कम एक फ़ंक्शन size_t sizeofTheType() प्रदान करना होगा जिससे उपयोगकर्ता उचित मात्रा में स्मृति और संभवतः अन्य सामान आवंटित कर सके।

Answer 5

सी ++ में यह संभव हो सकता है। लेकिन जहां तक ​​सी वाक्यविन्यास का उपयोग करना, यह असंभव है। तो आपको नीचे की तरह बदसूरत डीएसएल का उपयोग करना होगा।

#include <stdio.h> 
#include <assert.h> 

#define DEFINE_VAR(x) int ____________________ ## x = 0; 

#define VARIDATE_VAR(x) \ 
    assert(20 <= ____________________ ## x && ____________________ ## x <= 520); 

#define SET_VAR(x, y) { \ 
    ____________________ ## x = y; \ 
    VARIDATE_VAR(x) \ 
    } 

#define GET_VAR(x) ____________________ ## x 


int 
main(int argc, char* argv[]) { 
    DEFINE_VAR(n); 
    SET_VAR(n, 30); 
    return 0; 
}