2012-06-06 11 views
13

मुझे पता है कि क्रमशः डीबगिंग और उत्पादन के लिए रनटाइम पर दावा सक्षम/अक्षम किया जा सकता है। हालांकि मैंने पाया कि दावे भी उत्पन्न बाइनरी के आकार को बढ़ाते हैं (नीचे दिए गए उदाहरण में लगभग 100-200 बाइट)।बिना किसी दावा के संकलन

सी और सी ++ में, हम इसे #include <assert.h> से पहले संकलित समय पर कर सकते हैं।

जावा कंपाइलर के लिए स्वचालित रूप से ऐसा करने का कोई तरीका है? मैं उन्हें बाद में डीबगिंग उद्देश्यों के लिए स्रोत कोड में छोड़ना चाहता हूं। लेकिन मैं यह भी नहीं चाहता कि परिणामस्वरूप द्विआधारी आवश्यक से बड़ा हो (हमारे पास डिजाइन आवश्यकता के रूप में आकार सीमा है)।

सी कोड:

//#define NDEBUG 
#include <assert.h> 

int main(void) { 
    assert(0); // +200 bytes without NDEBUG, 0 with NDEBUG 
    return 0; 
} 

जावा कोड:।

public class Test { 
    public static void main(String[] args) { 
     assert(System.nanoTime()==0); // increases binary size by about 200 bytes 
    } 
} 

जवाब में अरब के जवाब:

public class Test2 { 
    public static final boolean assertions = false; 

    public static void main(String[] args) { 
     if(assertions) { 
      assert(System.nanoTime()==0); 
     } 
    } 
} 

संपादित करें: वास्तव में, ऐसा लगता है मेरे लिए यह सक्षम/अक्षम करना एक अधिक उपयोगी संकलन-समय है रन-टाइम की तुलना में ई सुविधा। मेरा मतलब है, कितने अंत उपयोगकर्ता उन्हें सक्षम करेंगे? जहां तक ​​एक प्रोग्रामर डीबग प्रक्रिया के दौरान चिंतित है, वैसे भी वह कोड को फिर से संकलित करेगा।

+0

यह साबित नहीं करता है कि प्रत्येक assert 200 बाइट्स खर्च करता है, केवल वह करता है। – EJP

+1

@EJP: निश्चित रूप से।मेरा मतलब यह था कि पूरी तरह से आवेषण के कारण एक गैर-लापरवाह वृद्धि हुई है। सटीक राशि निश्चित रूप से बयान की जटिलता पर निर्भर करती है। – tskuzzy

+1

यदि आप ऐसी चीजों से परेशान हैं, तो आप गलत भाषा के साथ हैं। – lvella

उत्तर

2

व्यक्तिगत तौर पर मैं ऐसा नहीं करेंगे क्योंकि निम्नलिखित जटिलता के स्रोत कोड को जोड़ा गया लेकिन javac के बाद दो टुकड़े में main के लिए ठीक उसी मध्यवर्ती कोड उत्पन्न:

सशर्त दावा

class C { 
    public final static boolean assertions = false; 

    public static void main(String[] args) { 
     if(assertions) { 
      assert(System.nanoTime()==0); 
     } 
    } 
} 

कोई दावा

class C { 
    public static void main(String[] args) { 
    } 
} 

संकलित कोड

public static void main(java.lang.String[]); 
    Code: 
     0: return   
    LineNumberTable: 
     line 3: 0 

संपादित

वास्तव में, मुझे लगता है कि यह सक्षम/अक्षम रन-टाइम की तुलना में अधिक उपयोगी संकलन समय की सुविधा है। मेरा मतलब है, उन्हें कितने अंतिम उपयोगकर्ता सक्षम करेंगे?

इसका अंत उपयोगकर्ताओं को सक्षम नहीं करता है, यह ग्राहक समर्थन है जो अंतिम उपयोगकर्ता को सक्षम करने के लिए कहता है। मेरी इच्छा है कि वे डिफ़ॉल्ट रूप से सक्षम, विकलांग नहीं थे।

+0

बिल्कुल सही धन्यवाद! मैं मानता हूं कि यह एक बहुत ही सुरुचिपूर्ण समाधान नहीं है लेकिन यह मेरे प्रश्न को संबोधित करता है। – tskuzzy

+0

ऐसा लगता है कि यदि आप अपने 'सार्वजनिक अंतिम स्थलीय बूलियन दावे = झूठे;' एक अलग वर्ग पर चर डालते हैं, ताकि आप अपने कोड पर सभी आवेषणों का उपयोग कर सकें और केवल एक ही स्थान पर ध्वज बदल सकें, आपको पूरे को फिर से सम्मिलित करना होगा स्रोत अगर यह बदला जाता है (और यह वांछनीय है, क्योंकि आप चाहते हैं कि चर आपके संकलित कोड से मिटा दिया गया हो)। – lvella

+0

@ इवेला ऐसा इसलिए है क्योंकि संकलक सार्वजनिक स्थिर फाइनल को रेखांकित करता है। –

4

यह एक संकलित संकलन चरण के रूप में संभव नहीं है। हालांकि, आप अपने दावे के आस-पास सशर्त ब्लॉक जोड़कर ऐसा कर सकते हैं।

अधिक जानकारी के लिए आलेख "Removing all Trace of Assertions from Class Files" देखें।

+0

एक अच्छा विचार की तरह लगता है, लेकिन वास्तव में यह बाइनरी को और भी 50 बाइट्स तक बढ़ा देता है। – tskuzzy

+0

यह बहुत समझ में नहीं आता है क्योंकि संकलक को बयान को पूरी तरह से हटा देना चाहिए क्योंकि यह अब पहुंच योग्य नहीं है। – Robin

+2

@ रॉबिन यदि ओपी 'अंतिम' का उपयोग करता है तो यह आकार को कम करेगा। –

संबंधित मुद्दे