दिलचस्प पोस्ट
क्यों मेरी jQuery: नहीं () चयनकर्ता सीएसएस में काम नहीं कर रहा है? स्क्रेपी और प्रॉक्सी हम ऐसा क्यों नहीं कर सकते सूची <मातृत्व> mylist = ArrayList <child> (); विशेषता और संपत्ति के बीच अंतर क्या है? JQuery.ajax और FormData का उपयोग कर फ़ाइल कैसे अपलोड करें एक इंटरैक्टिव प्रोग्राम के लिए द्विगुणिक अंतरण नहीं करना कैसे "वापस जाओ" समारोह में जोड़ें WebView टुकड़े के अंदर? एंड्रॉइड "केवल एक मूल धागा जो दृश्य पदानुक्रम बनाता है, उसके विचारों को छू सकता है।" SQL सर्वर: क्या एक ही समय में दो तालिकाओं में सम्मिलित करना संभव है? मुझे फ़ंक्शन हस्ताक्षर में std :: enable_if से क्यों बचने चाहिए? Sqlite3 में तेज थोक आवेषण? .net से कॉल आर (प्रोग्रामिंग लैंग्वेज) क्या आप कभी जावा में वाष्पशील कीवर्ड का उपयोग करते हैं? स्थिर फ़ाइलों को सेवा देने के लिए ASP.NET रूटिंग का उपयोग करना जावा से दो WAV फ़ाइलों में शामिल हों?

सी प्रीप्रोसेसर में थोड़ी देर लूप लेखन

मैं इस सवाल को शैक्षणिक / हैकिंग बिंदु से देख रहा हूं, (मैं वास्तव में ऐसा कोड नहीं चाहता)।

क्या सी प्रीप्रोसेसर डायरेक्टिव्स का उपयोग करते हुए केवल समय लूप को लागू करना संभव है मैं समझता हूं कि मैक्रोज़ का पुनरावर्ती रूप से विस्तार नहीं किया जा सकता है, तो यह कैसे पूरा होगा?

वेब के समाधान से एकत्रित समाधान "सी प्रीप्रोसेसर में थोड़ी देर लूप लेखन"

बूस्ट प्रीप्रोसेसर लाइब्रेरी पर एक नज़र डालें, जो आपको पूर्वप्रोसेसर में लूप लिखने की अनुमति देता है, और बहुत कुछ।

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

#define EMPTY() #define DEFER(id) id EMPTY() #define OBSTRUCT(id) id DEFER(EMPTY)() #define EXPAND(...) __VA_ARGS__ #define A() 123 A() // Expands to 123 DEFER(A)() // Expands to A () because it requires one more scan to fully expand EXPAND(DEFER(A)()) // Expands to 123, because the EXPAND macro forces another scan 

यह महत्वपूर्ण क्यों है? ठीक है जब एक मैक्रो स्कैन और विस्तार हो रहा है, तो यह एक अक्षम संदर्भ बनाता है। यह निष्क्रिय करने का संदर्भ टोकन का कारण होगा, जो वर्तमान में विस्तार करने वाले मैक्रो को दर्शाता है, जिसे नीले रंग से चित्रित किया जाता है। इस प्रकार, एक बार पेंट किए गए नीले रंग के बाद, मैक्रो अब विस्तार नहीं करेगा। यही कारण है कि मैक्रो बार-बार विस्तार नहीं करते हैं हालांकि, एक अक्षम संदर्भ केवल एक स्कैन के दौरान मौजूद होता है, इसलिए विस्तार को बढ़ाकर हम अपने मैक्रो को रंगीन नीले रंग से बनने से रोक सकते हैं। हमें अभिव्यक्ति के लिए अधिक स्कैन लागू करने की आवश्यकता होगी हम इस EVAL मैक्रो का उपयोग कर सकते हैं:

 #define EVAL(...) EVAL1(EVAL1(EVAL1(__VA_ARGS__))) #define EVAL1(...) EVAL2(EVAL2(EVAL2(__VA_ARGS__))) #define EVAL2(...) EVAL3(EVAL3(EVAL3(__VA_ARGS__))) #define EVAL3(...) EVAL4(EVAL4(EVAL4(__VA_ARGS__))) #define EVAL4(...) EVAL5(EVAL5(EVAL5(__VA_ARGS__))) #define EVAL5(...) __VA_ARGS__ 

इसके बाद, हम कुछ ऑपरेटरों को कुछ तर्क (जैसे कि, आदि) करने के लिए परिभाषित करते हैं:

 #define CAT(a, ...) PRIMITIVE_CAT(a, __VA_ARGS__) #define PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__ #define CHECK_N(x, n, ...) n #define CHECK(...) CHECK_N(__VA_ARGS__, 0,) #define NOT(x) CHECK(PRIMITIVE_CAT(NOT_, x)) #define NOT_0 ~, 1, #define COMPL(b) PRIMITIVE_CAT(COMPL_, b) #define COMPL_0 1 #define COMPL_1 0 #define BOOL(x) COMPL(NOT(x)) #define IIF(c) PRIMITIVE_CAT(IIF_, c) #define IIF_0(t, ...) __VA_ARGS__ #define IIF_1(t, ...) t #define IF(c) IIF(BOOL(c)) 

अब इन सभी मैक्रोज़ के साथ हम एक रिकर्सिव WHILE मैक्रो लिख सकते हैं। हम अपने आप को वापस पुनः संदर्भित करने के लिए एक WHILE_INDIRECT मैक्रो का उपयोग करते हैं यह मैक्रो को नीले रंग से चित्रित होने से रोकता है, क्योंकि यह एक अलग स्कैन पर विस्तार करेगा (और एक अलग अक्षम संदर्भ का उपयोग करके)। WHILE मैक्रो में एक वर्डिकेट मैक्रो, एक ऑपरेटर मैक्रो और एक स्टेट (जो भिन्नतापूर्ण तर्क है) लेता है। यह राज्य में इस ऑपरेटर मैक्रो को लागू करने तक रखता है जब तक कि पूर्वानुमानित मैक्रो झूठी रिटर्न (जो कि 0 है)।

 #define WHILE(pred, op, ...) \ IF(pred(__VA_ARGS__)) \ ( \ OBSTRUCT(WHILE_INDIRECT) () \ ( \ pred, op, op(__VA_ARGS__) \ ), \ __VA_ARGS__ \ ) #define WHILE_INDIRECT() WHILE 

प्रदर्शन के प्रयोजनों के लिए, हम सिर्फ एक विधेयक बनाने जा रहे हैं जो तर्क की संख्या 1 की जांच करता है:

 #define NARGS_SEQ(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N #define NARGS(...) NARGS_SEQ(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1) #define IS_1(x) CHECK(PRIMITIVE_CAT(IS_1_, x)) #define IS_1_1 ~, 1, #define PRED(x, ...) COMPL(IS_1(NARGS(__VA_ARGS__))) 

इसके बाद हम एक ऑपरेटर बनाते हैं, जिसे हम सिर्फ दो टोकन में पेश करेंगे। हम एक अंतिम ऑपरेटर ( M ) भी कहते हैं जो अंतिम आउटपुट को संसाधित करेगा:

 #define OP(x, y, ...) CAT(x, y), __VA_ARGS__ #define M(...) CAT(__VA_ARGS__) 

फिर WHILE मैक्रो का उपयोग करते हुए:

 M(EVAL(WHILE(PRED, OP, x, y, z))) //Expands to xyz 

बेशक, किसी भी प्रकार का विधेय या ऑपरेटर इसे पारित किया जा सकता है।

आप पुनरावर्ती शामिल फ़ाइलें उपयोग करते हैं दुर्भाग्यवश, आप अधिकतम गहराई से अधिक लूप को फिर से नहीं कर सकते, जो कि पूर्वप्रक्रमक की अनुमति देता है।

यह पता चला है कि C ++ टेम्पलेट पूर्ण ट्यूरिंग हैं और समान तरीके से उपयोग किया जा सकता है। जनरेटिंग प्रोग्रामिंग की जांच करें

यहां नियमों का दुरुपयोग है जो इसे कानूनी तौर पर किया जाएगा अपना स्वयं का प्रीप्रोसेसर लिखें इसे कुछ # प्रगामा निर्देशों को जिस तरह से आप चाहते हैं, उसे समझें।

मैं इस उद्देश्य के लिए मेटा-टेम्प्लेट प्रोग्रामिंग का उपयोग करता हूं, एक बार जब आप इसे लटका लेते हैं और समय पर विवेक के साथ उपयोग किए जाने पर बहुत उपयोगी होता है क्योंकि जैसा कि ट्यूरिंग पूर्ण हो गया है, उस बिंदु पर, जहां आप कंपाइलर को अनंत लूप या स्टैक-ओवरफ्लो में शामिल करने का कारण भी दे सकते हैं! आपके संकलन को 30+ गीगाबाइट मेमोरी और सभी सीपीयू को अपना अनंत लूप कोड संकलित करने के लिए उपयोग करने के लिए कुछ कॉफी मिलना पसंद नहीं है!

ठीक है, यह नहीं है कि यह एक लूप है, लेकिन एक काउंटर लूप, फिर भी पाश को साफ सीपीपी (कोई टेम्पलेट और कोई सी ++) में संभव नहीं है

 #ifdef pad_always #define pad(p,f) p##0 #else #define pad0(p,not_used) p #define pad1(p,not_used) p##0 #define pad(p,f) pad##f(p,) #endif // f - padding flag // p - prefix so far // a,b,c - digits // x - action to invoke #define n0(p,x) #define n1(p,x) x(p##1) #define n2(p,x) n1(p,x) x(p##2) #define n3(p,x) n2(p,x) x(p##3) #define n4(p,x) n3(p,x) x(p##4) #define n5(p,x) n4(p,x) x(p##5) #define n6(p,x) n5(p,x) x(p##6) #define n7(p,x) n6(p,x) x(p##7) #define n8(p,x) n7(p,x) x(p##8) #define n9(p,x) n8(p,x) x(p##9) #define n00(f,p,a,x) n##a(pad(p,f),x) #define n10(f,p,a,x) n00(f,p,9,x) x(p##10) n##a(p##1,x) #define n20(f,p,a,x) n10(f,p,9,x) x(p##20) n##a(p##2,x) #define n30(f,p,a,x) n20(f,p,9,x) x(p##30) n##a(p##3,x) #define n40(f,p,a,x) n30(f,p,9,x) x(p##40) n##a(p##4,x) #define n50(f,p,a,x) n40(f,p,9,x) x(p##50) n##a(p##5,x) #define n60(f,p,a,x) n50(f,p,9,x) x(p##60) n##a(p##6,x) #define n70(f,p,a,x) n60(f,p,9,x) x(p##70) n##a(p##7,x) #define n80(f,p,a,x) n70(f,p,9,x) x(p##80) n##a(p##8,x) #define n90(f,p,a,x) n80(f,p,9,x) x(p##90) n##a(p##9,x) #define n000(f,p,a,b,x) n##a##0(f,pad(p,f),b,x) #define n100(f,p,a,b,x) n000(f,p,9,9,x) x(p##100) n##a##0(1,p##1,b,x) #define n200(f,p,a,b,x) n100(f,p,9,9,x) x(p##200) n##a##0(1,p##2,b,x) #define n300(f,p,a,b,x) n200(f,p,9,9,x) x(p##300) n##a##0(1,p##3,b,x) #define n400(f,p,a,b,x) n300(f,p,9,9,x) x(p##400) n##a##0(1,p##4,b,x) #define n500(f,p,a,b,x) n400(f,p,9,9,x) x(p##500) n##a##0(1,p##5,b,x) #define n600(f,p,a,b,x) n500(f,p,9,9,x) x(p##600) n##a##0(1,p##6,b,x) #define n700(f,p,a,b,x) n600(f,p,9,9,x) x(p##700) n##a##0(1,p##7,b,x) #define n800(f,p,a,b,x) n700(f,p,9,9,x) x(p##800) n##a##0(1,p##8,b,x) #define n900(f,p,a,b,x) n800(f,p,9,9,x) x(p##900) n##a##0(1,p##9,b,x) #define n0000(f,p,a,b,c,x) n##a##00(f,pad(p,f),b,c,x) #define n1000(f,p,a,b,c,x) n0000(f,p,9,9,9,x) x(p##1000) n##a##00(1,p##1,b,c,x) #define n2000(f,p,a,b,c,x) n1000(f,p,9,9,9,x) x(p##2000) n##a##00(1,p##2,b,c,x) #define n3000(f,p,a,b,c,x) n2000(f,p,9,9,9,x) x(p##3000) n##a##00(1,p##3,b,c,x) #define n4000(f,p,a,b,c,x) n3000(f,p,9,9,9,x) x(p##4000) n##a##00(1,p##4,b,c,x) #define n5000(f,p,a,b,c,x) n4000(f,p,9,9,9,x) x(p##5000) n##a##00(1,p##5,b,c,x) #define n6000(f,p,a,b,c,x) n5000(f,p,9,9,9,x) x(p##6000) n##a##00(1,p##6,b,c,x) #define n7000(f,p,a,b,c,x) n6000(f,p,9,9,9,x) x(p##7000) n##a##00(1,p##7,b,c,x) #define n8000(f,p,a,b,c,x) n7000(f,p,9,9,9,x) x(p##8000) n##a##00(1,p##8,b,c,x) #define n9000(f,p,a,b,c,x) n8000(f,p,9,9,9,x) x(p##9000) n##a##00(1,p##9,b,c,x) #define n00000(f,p,a,b,c,d,x) n##a##000(f,pad(p,f),b,c,d,x) #define n10000(f,p,a,b,c,d,x) n00000(f,p,9,9,9,9,x) x(p##10000) n##a##000(1,p##1,b,c,d,x) #define n20000(f,p,a,b,c,d,x) n10000(f,p,9,9,9,9,x) x(p##20000) n##a##000(1,p##2,b,c,d,x) #define n30000(f,p,a,b,c,d,x) n20000(f,p,9,9,9,9,x) x(p##30000) n##a##000(1,p##3,b,c,d,x) #define n40000(f,p,a,b,c,d,x) n30000(f,p,9,9,9,9,x) x(p##40000) n##a##000(1,p##4,b,c,d,x) #define n50000(f,p,a,b,c,d,x) n40000(f,p,9,9,9,9,x) x(p##50000) n##a##000(1,p##5,b,c,d,x) #define n60000(f,p,a,b,c,d,x) n50000(f,p,9,9,9,9,x) x(p##60000) n##a##000(1,p##6,b,c,d,x) #define n70000(f,p,a,b,c,d,x) n60000(f,p,9,9,9,9,x) x(p##70000) n##a##000(1,p##7,b,c,d,x) #define n80000(f,p,a,b,c,d,x) n70000(f,p,9,9,9,9,x) x(p##80000) n##a##000(1,p##8,b,c,d,x) #define n90000(f,p,a,b,c,d,x) n80000(f,p,9,9,9,9,x) x(p##90000) n##a##000(1,p##9,b,c,d,x) #define cycle5(c1,c2,c3,c4,c5,x) n##c1##0000(0,,c2,c3,c4,c5,x) #define cycle4(c1,c2,c3,c4,x) n##c1##000(0,,c2,c3,c4,x) #define cycle3(c1,c2,c3,x) n##c1##00(0,,c2,c3,x) #define cycle2(c1,c2,x) n##c1##0(0,,c2,x) #define cycle1(c1,x) n##c1(,x) #define concat(a,b,c) a##b##c #define ck(arg) a[concat(,arg,-1)]++; #define SIZEOF(x) (sizeof(x) / sizeof((x)[0])) void check5(void) { int i, a[32769]; for (i = 0; i < SIZEOF(a); i++) a[i]=0; cycle5(3,2,7,6,9,ck); for (i = 0; i < SIZEOF(a); i++) if (a[i] != 1) printf("5: [%d] = %d\n", i+1, a[i]); } 

मैं यह योजना उपयोगी पाया जब कंपाइलर क्रैकी हो गया और मेरे लिए कुछ लूपों को नहीं खुलता

# परिभाषित REPEAT20 (x) {x; x; x; x; x; x; x; x; x; एक्स; एक्स; एक्स; एक्स; एक्स; एक्स; एक्स; एक्स; एक्स; एक्स; एक्स;};

REPEAT20 (वैल = कृपया कनवर्जेज (वैल));

लेकिन आईएमएचओ, अगर आपको उस की तुलना में अधिक जटिल की आवश्यकता है, तो आपको अपना खुद का प्री-प्रोप्रोसेसर लिखना चाहिए। आपके प्री-प्रोप्रोसेसर, उदाहरण के लिए आपके लिए एक उचित हेडर फाइल जेनरेट कर सकता है, और मेकफाइल में यह चरण शामिल करना काफी आसान है, ताकि प्रत्येक आदेश को एक ही आदेश द्वारा सुचारू रूप से संकलित किया जा सके। मेंने यह किया है।

आपके द्वारा जो कुछ भी पूछा नहीं, लेकिन सी लिंक पर इन लिंक की जांच करें जो कि एक मान्य makefile और शेल स्क्रिप्ट भी है।

एक सी प्रोग्राम (?) बनाने के लिए सी, मेक और शेल कोड एक-दूसरे पर निर्माण करते हैं, जब एक शेल स्क्रिप्ट के रूप में निष्पादित किया जाता है तो सी कम्पाइलर के जरिए एक मेकफील का उपयोग करके खुद को संकलित करेगा!

2000 में विवादित सी प्रतियोगिता में विजेता

http://www.ioccc.org/2000/tomx.c
http://www.ioccc.org/2000/tomx.hint