सच तालिकाओं को लागू करने के लिए सामान्य पैटर्न

Question

क्या सच तालिकाओं को लागू करने के लिए एक अच्छा सामान्य पैटर्न है?

मैं कुछ विरासत कोड (सी ++) दोबारा काम कर रहा हूं और मुझे एहसास हुआ कि जिस समारोह में मैं काम कर रहा हूं, जिसमें 3 बाइनरी इनपुट और 8 संभावित आउटपुट के साथ एक सत्य तालिका है। अगर वहाँ एक क्लीनर, अधिक maintainable/एक्स्टेंसिबल * जिस तरह से सेट अप करने के लिए है

// - + + 
if ((prevdst5 < 0.0) && (dst5 > 0.0) && (nextdst5 > 0.0)){ 
    thawpct = (dst5/(dst5 - prevdst5)); 
} 

// - - + 
if ((prevdst5 < 0.0) && (dst5 < 0.0) && (nextdst5 > 0.0)){ 
    thawpct = (nextdst5/(nextdst5 - dst5)); 
} 

// other cases... 

return thawpct; 

मूल रूप से मैं सोच रहा हूँ: यहाँ आठ परीक्षण और इसी निर्गम की दो का एक उदाहरण है।

• यदि कोई अन्य इनपुट जोड़ा जाता है तो क्या होगा? फिर यदि आवश्यक बयानों की संख्या 16 होगी, जो मेरे विचार में, वर्तमान पैटर्न के साथ प्रबंधन करने के लिए बहुत बोझिल होगी।
• क्या होगा अगर इनपुट इनपुट में से कई को एक ही आउटपुट में मैप करना चाहिए?

* कोडबेस एक पारिस्थितिक तंत्र मॉडल है जो अकादमी में उपयोग किया जाता है, इसलिए कोडर के परिप्रेक्ष्य के आधार पर समान चीजों के रखरखाव और विस्तार राशि।

Answer 1

एक सरणी एक सारणी है।

बुलियन सत्य मानों का एक अनुक्रम एक बाइनरी संख्या है।

Arrays संख्या से अनुक्रमित हैं।

Sooooo .....

आप एक समारोह प्रत्येक गणना के लिए निर्धारित कर सकते हैं:

// - + + == 0 1 1 == 3 
inline double f3(double prev, double curr, double next) 
{ 
    return curr/(curr - prev); 
} 

// - - + == 0 0 1 == 1 
inline double f1(double prev, double curr, double next) 
{ 
    return next/(next - curr); 
} 

// ... 

तब समारोह संकेत की एक सरणी की घोषणा:

typedef double (*func_type)(double, double, double); 
func_type funcs[8] = { 
    f1, f2, // ... 
}; 

फिर सूचकांक सरणी में बूलियन अंकों के रूप में बूलियन स्थितियों का उपयोग करके:

func_type f = funcs[ (int(prevdst5 < 0.0)<<2) | (int(dst5 < 0.0)<<1) | int(nextdst5 > 0.0) ]; 
thawpct = f(prevdst5, dst5, nextdst5); 

• यदि कोई अन्य इनपुट जोड़ा जाता है तो क्या होगा? (फिर परीक्षण की संख्या 16 हो सकता है, जो मेरे विचार में वर्तमान पैटर्न के साथ प्रबंधन करने के लिए बोझिल होगा)

आप सरणी के आकार को दोगुना और f8, f9 आदि जोड़ने के अलग गणना कर रहे हैं जरूरत है, लेकिन आप केवल नए परीक्षण एक बार जोड़ने के लिए, सरणी सूचकांक में:

func_type f = funcs[ (cond<<3) | (int(prevdst5 < 0.0)<<2) | (int(dst5 < 0.0)<<1) | int(nextdst5 > 0.0) ]; 

• क्या होगा यदि इनपुट कॉम्बो के कई एक ही उत्पादन के लिए नक्शे चाहिए?

स्टोर सरणी के कई तत्वों पर एक ही समारोह सूचक:

func_type funcs[8] = { 
    f1, f2, f3, f1, f1, // ... 
}; 

Answer 2

आप उचित कार्य को करने की आवश्यकता है कि करने के लिए 3 (या n) मूल्यों की एक मानचित्रण रख सकता है।फिर true/false कंडिटन की स्थिति के आधार पर इस मानचित्र में फ़ंक्शन को लूप करें और उसे निष्पादित करें।

इस तरह आप (सभी आयाम में आकार 2) के साथ एक 3 आयामी नक्शा

Answer 3

int condition = (prev >= 0 ? (1<<0) : 0) + 
       (cur >= 0 ? (1<<1) : 0) + 
       (next >= 0 ? (1<<2) : 0); 

switch (condition) { 
    case 0: // - - - 
    case 1: // + - - 
    case 2: // - + - 
    case 3: // + + - 
    case 4: // - - + 
    case 5: // + - + 
    case 6: // - + + 
    case 7: // + + + 
}