कॉपी-पेस्ट और म्यून्स

अब मैं बात करूंगा और उदाहरणों के साथ दिखाऊंगा कि भौतिकविदों को स्थिर कोड विश्लेषण टूल का उपयोग क्यों करना चाहिए। मैं चाहूंगा कि पीवीएस-स्टूडियो यह उपकरण हो। लेकिन, निश्चित रूप से, कोई अन्य उपकरण भी उपयोगी होगा। कोड विश्लेषक डिबगिंग अनुप्रयोगों के लिए समय कम करेगा और बेवकूफ त्रुटियों से सिरदर्द कम करेगा। भौतिकी के बारे में अधिक सोचना बेहतर है और सी ++ कार्यक्रमों में त्रुटियों के बारे में कम है।

दुःख देने वाला

वास्तव में, यह लेख "अतीत" निकला। गलतियाँ उन लोगों द्वारा भी की जाती हैं जो दूसरों की गलतियों की तलाश करते हैं। :)

मैंने अनदेखा कर दिया। मैंने एक नए युवा कर्मचारी को सत्यापन के लिए Geant4 परियोजना की तैयारी सौंपी। सोर्स कोड को डाउनलोड करना, विजुअल स्टूडियो के लिए एक प्रोजेक्ट तैयार करना, और आम तौर पर वह सब कुछ करना आवश्यक था जिससे मैं ले सकता था और जांच सकता था। उसने यह सब किया। मैंने अभी Geant4_9_4 का पहला उपलब्ध प्राचीन संस्करण लिया, जिसका वर्णन विंडोज में एक परियोजना के निर्माण पर किया गया था। हाँ! मुझे इस बारे में तब पता चला जब मैंने यह लेख लिखा।

हालाँकि, इसका एक सकारात्मक पक्ष है। मैंने एक नया लेख लिखा, " कंटीन्यूइंग गेन्ट 4 वैलिडेशन, " जो ताज़ा स्रोत कोड (संस्करण 10.0-बीटा) का विश्लेषण करता है। अब आप यह पता लगा सकते हैं कि क्या त्रुटियां तय की गई हैं, जिसका अर्थ है कि उन्हें स्थैतिक विश्लेषण का उपयोग करके बहुत पहले और आसान पाया जा सकता है। और आप उन त्रुटियों को देख सकते हैं जो अभी भी छिपा रहे हैं।

नए संस्करण में लेख में सूचीबद्ध सोलह चेतावनियों में से:

• गायब हो गया: 6
• बायां: 10

इसलिए, हालांकि यह लेख प्रासंगिक नहीं है, यह पीवीएस-स्टूडियो कोड विश्लेषक की क्षमताओं को बहुत अच्छी तरह से दिखाता है। यह इतना महत्वपूर्ण नहीं है कि पुरानी परियोजना की जाँच की जाए। यह महत्वपूर्ण है कि कोड लिखने के चरण में भी कितनी त्रुटियों से बचा जा सकता है।

परिचय

मैं वैज्ञानिक उद्देश्यों के लिए उपयोग किए गए कोड के विश्लेषण पर नोटों की एक श्रृंखला जारी रखता हूं। पिछले नोट:

• बिग कैलकुलेटर हाथ से निकल जाता है
• हम cppcheck के बाद मशरूमिंग करते हैं

इस बार, Geant4 परियोजना अगले मोड़ पर है। यहाँ विकिपीडिया से लिया गया परियोजना का विवरण दिया गया है :

Geant4 (Eng। ज्यामिति एएनडी ट्रैकिंग - ज्यामिति और ट्रैकिंग) - मोंटे कार्लो विधियों का उपयोग करके पदार्थ के माध्यम से प्राथमिक कणों के पारित होने के लिए एक कार्यक्रम। CERN में ऑब्जेक्ट ओरिएंटेड C ++ प्रोग्रामिंग लैंग्वेज में विकसित किया गया। यह GEANT के पिछले संस्करणों का एक और विकास है, काफी संशोधित और पूरक है।

जैसा कि परियोजना की आधिकारिक वेबसाइट पर कहा गया है, "अनुप्रयोगों में उच्च-ऊर्जा भौतिकी और परमाणु प्रतिक्रिया अनुसंधान, चिकित्सा, कण त्वरक और अंतरिक्ष अनुसंधान शामिल हैं।" सॉफ्टवेयर का उपयोग दुनिया भर में कई शोध परियोजनाओं में किया जाता है।

परियोजना की वेबसाइट: http://geant4.org किसी प्रोजेक्ट का औसत आकार 76 मेगाबाइट का सोर्स कोड होता है। तुलना के लिए:

• वर्चुअडब प्रोजेक्ट - 13 मेगाबाइट;
• अपाचे HTTP सर्वर परियोजना - 26 मेगाबाइट
• क्रोमियम परियोजना (अतिरिक्त पुस्तकालयों के साथ) - 710 मेगाबाइट।

विश्लेषण के लिए, पीवीएस-स्टूडियो कोड विश्लेषक का उपयोग किया गया था। चूंकि Geant4 प्रोजेक्ट छोटा नहीं है, इसलिए इसमें दिलचस्प खोजने का मौका बहुत शानदार था। आपको केवल छोटी परियोजनाओं में त्रुटियां नहीं मिलेंगी ( गैर-रैखिक त्रुटि घनत्व देखें )। बेशक, बड़ी परियोजनाएं हैं जहां पीवीएस-स्टूडियो को कुछ भी नहीं मिलता है। क्षमा करें, लेकिन यह केवल एक अपवाद है।

मैं तुरंत माफी मांगना चाहता हूं अगर मैंने गलती से भौतिकी के बारे में किसी तरह की बकवास लिखी। लेकिन ध्यान दें कि मैं सॉफ्टवेयर में त्रुटियों को खोजने में सक्षम था, न कि पार्टियों के सार को समझने में, और वास्तव में परमाणु प्रतिक्रियाओं से संबंधित लगभग सब कुछ!

नोट। लेख में उन सभी को सूचीबद्ध नहीं किया गया है जिन्हें देखा गया था। चेतावनियों की एक और पूरी सूची जो मैंने देखी: geant4_old.txt ।

आइए देखें कि हमें Geant4 कोड में क्या दिलचस्प मिला।

कॉपी-पेस्ट और म्यून्स

म्यून्स के बारे में , मैं केवल यह जानता हूं कि यह एक प्राथमिक कण है। लेकिन मैं बेहतर समझता हूं कि कॉपी-पेस्ट क्या है। यहां एक त्रुटि का एक सुंदर उदाहरण है जब कोड की एक पंक्ति को प्रचारित किया गया था। कॉपी की गई लाइनों में बदलाव आया है, लेकिन हर जगह नहीं। परिणाम:

void G4QMessenger::SetNewValue(G4UIcommand* aComm, G4String aS) { if(photoDir) { if (aComm==theSynchR) thePhoto->SetSynchRadOnOff(aS); else if(aComm==minGamSR) thePhoto->SetMinGammaSR(.... else if(aComm==theGamN) thePhoto->SetGammaNuclearOnOff(.... else if(aComm==theMuoN) thePhoto->SetElPosNuclearOnOff(.... else if(aComm==theMuoN) thePhoto->SetMuonNuclearOnOff(aS); else if(aComm==theMuoN) thePhoto->SetTauNuclearOnOff(aS); else if(aComm==biasPhotoN)thePhoto->SetPhotoNucBias(.... } .... } 

PVS-Studio चेतावनी: V517 'if (A) {...} का उपयोग if (A) {...}' पैटर्न का पता चला। तार्किक त्रुटि उपस्थिति की संभावना है। चेक लाइनें: 195, 196. G4phys_builders g4qmessenger.cc 195

तीन बार दोहराए गए चेक पर ध्यान दें (aComm == theMuoN)।

नोट। बग को Gint4 के नए संस्करण में तय किया गया है। या यह कोड हटा दिया गया है।

बेरियन क्षय

रेडियोधर्मी क्षय का अध्ययन करना मुश्किल है या प्रोटॉन क्षय का पता लगाने की कोशिश करना। जब प्रोग्राम में त्रुटियां होती हैं तो ऐसा करना विशेष रूप से कठिन होता है।

 void G4QEnvironment::DecayBaryon(G4QHadron* qH) { .... else if(qM<mSzPi) // Only Lambda+PiM is possible { fQPDG=lQPDG; // Baryon is Lambda fMass=mLamb; sQPDG=pimQPDG; // Meson is Pi- sMass=mPi; } else if(qM<mSzPi) // Both Lambda+PiM & Sigma0+PiM are possible { if(G4UniformRand()<.6) { .... } 

PVS-Studio चेतावनी: V517 'if (A) {...} का उपयोग if (A) {...}' पैटर्न का पता चला। तार्किक त्रुटि उपस्थिति की संभावना है। चेक लाइनें: 8373, 8380. G4hadronic_body_ci g4qenvironment.cc 8373

एक ही स्थिति का उपयोग दो बार किया जाता है (qM <mSzPi)। इसका मतलब यह है कि हम कभी भी उस शाखा में नहीं पहुंचेंगे जिस पर टिप्पणी "// लैम्ब्डा + पीएएम और सिग्मा + पीएएम दोनों संभव हो"।

नोट। बग को Gint4 के नए संस्करण में तय किया गया है। या यह कोड हटा दिया गया है।

भाग की संख्या गिनें

पार्टन हैड्रोन का एक बिंदु-जैसा घटक है, लेप्टन और अन्य हैड्रोन द्वारा हैड्रोन के गहरे इनलेटस्टिक बिखरने पर प्रयोगों में प्रकट होता है।

यह अफ़सोस की बात है, लेकिन उनकी संख्या गिनने में समस्या है:

 G4bool G4CollisionMesonBaryonElastic:: IsInCharge(const G4KineticTrack& trk1, const G4KineticTrack& trk2) const { G4bool result = false; G4ParticleDefinition * p1 = trk1.GetDefinition(); G4ParticleDefinition * p2 = trk2.GetDefinition(); if( (GetNumberOfPartons(p1) != 2 || GetNumberOfPartons(p2) != 3) ||(GetNumberOfPartons(p1) != 3 || GetNumberOfPartons(p2) != 2) ) { result = false; } .... } 

PVS-Studio चेतावनी: V547 अभिव्यक्ति हमेशा सच है। संभवतः '&&' ऑपरेटर का उपयोग यहां किया जाना चाहिए। G4had_im_r_matrix g4collisionmesonbaryonelastic.cc 53

तुरंत त्रुटि का सार अदृश्य हो सकता है। इसलिए, मैं अभिव्यक्ति को सरल करूंगा:

 A = GetNumberOfPartons(p1); B = GetNumberOfPartons(p2); if ( (A != 2 || B != 3) || (A != 3 || B != 2) ) 

सादगी के लिए ब्रैकेट भी गिराए जा सकते हैं। हमें मिलता है:

 if ( A != 2 || B != 3 || A != 3 || B != 2 ) 

यह शर्त हमेशा सच होती है। चर not A ’हमेशा 2 के बराबर या 3 के बराबर नहीं होता है। इसी प्रकार चर। B’ के साथ होता है। जाहिर है, कहीं न कहीं एक भ्रम था। सबसे अधिक संभावना है, ऑपरेटर 'और&' यहां मौजूद होना चाहिए।

नोट। बग को Gint4 के नए संस्करण में तय किया गया है। या यह कोड हटा दिया गया है।

कूलंब नाकाबंदी और सरणी की सीमाओं से परे जा रहा है

कूलम्ब नाकाबंदी - बिंदु पर इलेक्ट्रॉन से संपर्कों में इलेक्ट्रॉनों के प्रतिकर्षण के साथ-साथ दो अतिरिक्त सुरंगों के बीच जुड़े एक क्वांटम डॉट के माध्यम से इलेक्ट्रॉनों के मार्ग को अवरुद्ध करता है, साथ ही साथ एक अतिरिक्त कूलम्ब संभावित बाधा है, जो एक इलेक्ट्रॉन बनाता है जो बिंदु पर बैठता है।

SetCoulombEffects () फ़ंक्शन के साथ कुछ गड़बड़ है। गैर-मौजूद उपश्रेणियों के पते सिग पॉइंटर ऐरे में रखे जाते हैं। 'सिग' के साथ काम करने से अपरिभाषित कार्यक्रम व्यवहार को बढ़ावा मिलेगा। यदि कार्यक्रम आपातकालीन मोड में समाप्त हो जाता है तो यह अच्छा है। यह बहुत बुरा है अगर कार्यक्रम काम करना जारी रखे और अन्य सरणियों और चर द्वारा कब्जा की गई मेमोरी को बेतरतीब ढंग से पढ़ और लिख देगा।

 enum { NENERGY=22, NANGLE=180 }; class G4LEpp : public G4HadronicInteraction { .... G4float * sig[NANGLE]; static G4float SigCoul[NENERGY][NANGLE]; .... }; G4LEpp::SetCoulombEffects(G4int State) { if (State) { for(G4int i=0; i<NANGLE; i++) { sig[i] = SigCoul[i]; } elab = ElabCoul; } .... } 

PVS- स्टूडियो चेतावनी: V557 ऐरे ओवररन संभव है। 'I' इंडेक्स का मान 179 तक पहुंच सकता है। g4lepp.cc 62

'सिग' ऐरे में 180 पॉइंटर्स हैं। इन बिंदुओं को द्वि-आयामी सरणी 'सिगौल' की विभिन्न रेखाओं का उल्लेख करना चाहिए। लेकिन 'सिगौल' एरे में केवल 22 पंक्तियाँ हैं। यह पता चलता है कि 'सिग' ऐरे में अधिकांश पॉइंटर्स यह स्पष्ट नहीं करेंगे कि कहाँ है।

यह कहना मुश्किल है कि त्रुटि क्या है। हो सकता है कि 'सिगौल' ऐरे को गलत घोषित कर दिया गया हो। उदाहरण के लिए, आपको पंक्तियों और स्तंभों की संख्या को स्वैप करना होगा:

सिगौल [NENERGY] [NANGLE] - >> सिगौल [NANGLE] [NENERGY]

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

टाइपो और ट्विस्ट सतहों

 void G4VTwistSurface::GetBoundaryLimit(G4int areacode, G4double limit[]) const { .... if (areacode & sC0Min1Max) { limit[0] = fAxisMin[0]; limit[1] = fAxisMin[1]; } else if (areacode & sC0Max1Min) { limit[0] = fAxisMax[0]; limit[1] = fAxisMin[1]; } else if (areacode & sC0Max1Max) { limit[0] = fAxisMax[0]; limit[1] = fAxisMax[1]; } else if (areacode & sC0Min1Max) { limit[0] = fAxisMin[0]; limit[1] = fAxisMax[1]; } .... } 

PVS-Studio चेतावनी: V517 'if (A) {...} का उपयोग if (A) {...}' पैटर्न का पता चला। तार्किक त्रुटि उपस्थिति की संभावना है। चेक लाइन: 793, 802. G4specsolids g4vtwistsurface.cc 793

4 चर हैं:

• sC0Min1Max
• sC0Max1Min
• sC0Min1Min
• sC0Max1Max

सीमाओं के साथ काम करते समय, उनमें से केवल 3 का उपयोग किया जाता है। इस स्थिति में, चेक (एरियाकोड और sC0Min1Max) 2 बार किया जाता है। यदि आप बारीकी से देखते हैं, तो आप देख सकते हैं कि पहली जांच के बाद, मिनिमा का चयन किया गया है: fAxisMin [0], fAxisMin [1]। सबसे अधिक संभावना है, पहला चेक इस तरह होना चाहिए:

 if (areacode & sC0Min1Min) { limit[0] = fAxisMin[0]; limit[1] = fAxisMin[1]; } <b>.      Gint4.    .</b> 

एक्स-रे और गलत आई.एफ.

एक्स-रे विकिरण - विद्युत चुम्बकीय तरंगें जिनकी फोटॉन ऊर्जा पराबैंगनी विकिरण और गामा विकिरण के बीच विद्युत चुम्बकीय तरंगों के पैमाने पर होती है।

जैसा कि मैं इसे समझता हूं, G4ForwardXrayTR वर्ग एक्स-रे से संबंधित है। सूचकांकों की तुलना में त्रुटि सामने आई।

 G4VParticleChange* G4ForwardXrayTR::PostStepDoIt(....) { .... if (iMat == jMat || ( (fMatIndex1 >= 0 && fMatIndex1 >= 0) && ( iMat != fMatIndex1 && iMat != fMatIndex2 ) && ( jMat != fMatIndex1 && jMat != fMatIndex2 ) ) .... } 

PVS-Studio चेतावनी: V501 बाईं और '&&' ऑपरेटर के दाईं ओर समान उप-अभिव्यक्तियाँ हैं: fMatIndex1> = 0 && fMatIndex1> = 0 G4xrward g4forwardxraytr.cc 620

'FMatIndex1' नाम के एक इंडेक्स को दो बार जांचा जाता है। और वे fMatIndex2 के बारे में भूल गए। शायद इस तरह लिखा जाना चाहिए:

 (fMatIndex1 >= 0 && fMatIndex2 >= 0) 

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

टाइपो और न्यूट्रॉन

 G4double G4MesonAbsorption:: GetTimeToAbsorption( const G4KineticTrack& trk1, const G4KineticTrack& trk2) { .... if(( trk1.GetDefinition() == G4Neutron::Neutron() || trk1.GetDefinition() == G4Neutron::Neutron() ) && sqrtS>1.91*GeV && pi*distance>maxChargedCrossSection) return time; .... } 

PVS-Studio चेतावनी: V501 समान उप-अभिव्यक्तियाँ हैं 'trk1.GetDefinition () == G4Neutron :: Neutron ()' बाईं ओर और 'दाईं ओर' || ऑपरेटर। G4had_im_r_matrix g4mesonabsorption.cc 285

हां, मुझे नहीं पता कि यह कार्य क्या करता है। लेकिन, जैसा कि यह मुझे लगता है, प्रवेश द्वार पर यह प्राथमिक कणों के दो प्रक्षेपवक्र प्राप्त करता है। फ़ंक्शन को एक विशेष तरीके से स्थिति को संभालना चाहिए यदि कम से कम एक कण एक न्यूट्रॉन है। लेकिन, वास्तव में, केवल पहले कण की जांच की जाएगी।

जाहिर है, वास्तव में, उन्होंने लिखने की योजना बनाई:

 trk1.GetDefinition() == G4Neutron::Neutron() || trk2.GetDefinition() == G4Neutron::Neutron() 

एक समान टाइपो यहां पाया जा सकता है: g4scatterer.cc 138

नोट। बग को Gint4 के नए संस्करण में तय किया गया है। या यह कोड हटा दिया गया है।

पार्टन को जोड़ना

एक InsertParton () फ़ंक्शन है जो एक कंटेनर में एक parton सम्मिलित करता है। आप निर्दिष्ट कर सकते हैं कि किस पार्टन के बाद आप एक नया तत्व सम्मिलित करना चाहते हैं। यदि सम्मिलन बिंदु निर्दिष्ट नहीं है, तो आप शायद इसे कहीं भी चिपका सकते हैं। लेकिन सिर्फ इस मामले को गलत तरीके से लागू किया गया है।

 typedef std::vector<G4Parton *> G4PartonVector; inline void G4ExcitedString::InsertParton( G4Parton *aParton, const G4Parton * addafter) { G4PartonVector::iterator insert_index; .... if ( addafter != NULL ) { insert_index=std::find(thePartons.begin(), thePartons.end(), addafter); .... } thePartons.insert(insert_index+1, aParton); } 

PVS-Studio चेतावनी: V614 संभावित रूप से एकतरफा चलने वाले itter 'insert_index' का उपयोग किया जाता है। g4excitedstring.hh 193

यदि 'addafter' पॉइंटर शून्य है, तो इन्सर्ट_इन्डेक्स इटरेटर अनइंस्टालिनेटेड रहता है। नतीजतन, एक नई वस्तु डालने से अप्रत्याशित परिणाम हो सकते हैं।

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

सभी न्यूक्लियर प्रोसेसिंग नहीं

न्यूक्लियॉन प्रोटॉन और न्यूट्रॉन का सामान्य नाम है।

एक फ़ंक्शन पैकन्यूक्लियोन () है जो सभी तत्वों को संसाधित नहीं करता है। तथ्य यह है कि पहले पुनरावृत्ति के तुरंत बाद चक्र समाप्त होता है। लूप बॉडी के अंत में एक 'ब्रेक' स्टेटमेंट होता है, लेकिन इसे जारी रखने के लिए कहीं नहीं है।

 void G4QMDGroundStateNucleus::packNucleons() { .... while ( nmTry < maxTrial ) { nmTry++; G4int i = 0; for ( i = 1 ; i < GetMassNumber() ; i++ ) { .... } if ( i == GetMassNumber() ) { areTheseMsOK = true; } break; } .... } 

पीवीएस-स्टूडियो चेतावनी: वी 612 एक लूप के भीतर बिना शर्त 'ब्रेक'। g4qmdgroundstatenucleus.cc 274

यह मुझे लगता है कि अंत में 'ब्रेक' ऑपरेटर दुर्घटना से बहुत ही कमज़ोर और लिखित है।

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

इंडेक्स में लंड स्ट्रिंग मॉडल और टाइपो

कण भौतिकी में, लुंड स्ट्रिंग मॉडल हेड्रोनिज़्म का एक अभूतपूर्व मॉडल है।

जब आपको एरे के व्यक्तिगत तत्वों के साथ काम करना होता है, तो टाइपो बनाना बहुत आसान होता है। यह वास्तव में G4LundStringFragmentation वर्ग के कंस्ट्रक्टर में हुआ है। नीचे दिए गए कोड में, त्रुटि तुरंत दिखाई देती है। हम एक ही सेल में दो बार मान प्रदान करते हैं। हालांकि, यह एक बहुत बड़ा कार्य है जहां कई सरणी तत्व आरंभीकृत होते हैं। और एक फ़ंक्शन पर विचार करते समय एक गलती को नोटिस करना एक अत्यंत कठिन कार्य है। यह वह स्थिति है जहां स्थैतिक कोड विश्लेषण केवल अपूरणीय है।

 G4LundStringFragmentation::G4LundStringFragmentation() { .... BaryonWeight[0][1][2][2]=pspin_barion*0.5; .... BaryonWeight[0][1][2][2]=(1.-pspin_barion); .... } 

PVS-Studio चेतावनी: V519 'BaryonWeight [0] [1] [2] [2]' चर को क्रमिक रूप से दो बार मान दिया गया है। शायद यह एक गलती है। चेक लाइनें: 205, 208. g4lundstringfragmentation.cc 208

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

वैसे, दृष्टिकोण बहुत स्पष्ट नहीं है जब पहली बार में चर को डिफ़ॉल्ट मान के साथ शुरू किया जाता है, और फिर वांछित मूल्य के साथ। इसकी आवश्यकता क्यों है? एक चर को तुरंत घोषित करना आसान है जहां इसकी आवश्यकता है और इसे सही संख्या के साथ प्रारंभ करें।

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

कुछ अन्य V519 चेतावनियाँ

G4KineticTrack क्लास में कॉपी ऑपरेटर संदिग्ध दिखता है:

 const G4KineticTrack& G4KineticTrack::operator=( const G4KineticTrack& right) { .... the4Momentum = right.the4Momentum; the4Momentum = right.GetTrackingMomentum(); .... } 

PVS-Studio चेतावनी: V519 'the4Momentum' वेरिएबल को क्रमिक रूप से दो बार मान दिया गया है। शायद यह एक गलती है। चेक लाइनें: 451, 452. g4kinetictrack.cc 452

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

वैसे, डिजाइनरों पर बहुत सारे V519 चेतावनी थे। शायद ऐसे कोड में एक बिंदु है? उदाहरण के लिए, डिबगिंग उद्देश्यों के लिए। यह स्पष्ट नहीं है। इसलिए मुझे लगता है कि यह संदिग्ध कोड के कुछ और उदाहरण देने लायक है:

 void G4IonisParamMat::ComputeDensityEffect() { .... fX0density = 0.326*fCdensity-2.5 ; fX1density = 5.0 ; fMdensity = 3. ; while((icase > 0)&&(fCdensity < ClimiG[icase])) icase-- ; fX0density = X0valG[icase]; fX1density = X1valG[icase]; .... } 

PVS-Studio चेतावनियाँ: V519 'fX0density' चर को क्रमिक रूप से दो बार मान दिया गया है। शायद यह एक गलती है। चेक लाइनें: 245, 247. g4ionisparammat.cc 247

V519 'fX1density' चर को क्रमिक रूप से दो बार मान दिया गया है। शायद यह एक गलती है। चेक लाइनें: 245, 247. g4ionisparammat.cc 247

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

 void G4AdjointPhotoElectricModel::SampleSecondaries(....) { .... pre_step_AdjointCS = totAdjointCS; post_step_AdjointCS = AdjointCrossSection(aCouple, electronEnergy,IsScatProjToProjCase); post_step_AdjointCS = totAdjointCS; .... } 

PVS-Studio चेतावनी: V519 'post_step_AdjointCS' चर को क्रमिक रूप से दो बार मान दिया गया है। शायद यह एक गलती है। जाँच लाइनें: 76, 77. g4adjointphotoelectricmodel.cc 77

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

और आखिरी संदिग्ध टुकड़ा जो मैंने देखा। 'एरेकेम' के सदस्य पर ध्यान दें।

 void G4Incl::processEventIncl(G4InclInput *input) { .... varntp->mzini = izrem; varntp->exini = esrem; varntp->pxrem = pxrem; varntp->pyrem = pyrem; varntp->pzrem = pzrem; varntp->mcorem = mcorem; varntp->erecrem = pcorem; varntp->erecrem = erecrem; .... } 

PVS-Studio चेतावनी: V519 'varntp-> erecrem' चर को लगातार दो बार मान दिया गया है। शायद यह एक गलती है। चेक लाइनें: 896, 897. g4incl.cc 897

नोट। बग को Gint4 के नए संस्करण में तय किया गया है। या यह कोड हटा दिया गया है।

1 के साथ सरणी तत्वों की गणना

यह मुझे लगता है कि कोई व्यक्ति एक पल के लिए भूल गया कि सी ++ में सरणियों के तत्व खरोंच से गिने जाते हैं। परिणामस्वरूप, एक आउटबाउंड सरणी हो सकती है। साथ ही, सरणी के बहुत शुरुआत में स्थित मूल्य 1.4 के साथ कोई तुलना नहीं है।

 void G4HEInelastic::MediumEnergyClusterProduction(....) { .... G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00}; .... for (j = 1; j < 8; j++) { if (alekw < alem[j]) { jmax = j; break; } } .... } 

PVS- स्टूडियो चेतावनी: V557 ऐरे ओवररन संभव है। 'J' इंडेक्स का मान 7. g4heinelastic.cc 4682 तक पहुँच सकता है

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

भौतिकी और अपरिभाषित व्यवहार

C ++ एक क्रूर भाषा है। उसने थोड़ा आराम किया और तुरंत अपने प्रोटॉन के साथ अपने पैर को गोली मार दी। इसके अलावा, यह अभी ध्यान नहीं दिया जा सकता है। गलत तरीके से लागू किए गए ऑपरेटर के उदाहरण यहां दिए गए हैं:

 template <typename T> GMocrenDataPrimitive<T> & GMocrenDataPrimitive<T>::operator + (const GMocrenDataPrimitive<T> & _right) { GMocrenDataPrimitive<T> rprim; .... return rprim; } 

PVS-Studio चेतावनी: V558 फ़ंक्शन अस्थायी स्थानीय ऑब्जेक्ट का संदर्भ देता है: rprim। G4GMocren g4gmocrenio.cc 131

फ़ंक्शन किसी स्थानीय ऑब्जेक्ट का लिंक देता है। इस लिंक के साथ काम करने का प्रयास अपरिभाषित व्यवहार के परिणामस्वरूप होगा।

नोट। त्रुटि अभी भी Gint4 के नए संस्करण में मौजूद है।

यह समय गोल करने का है

दुर्भाग्य से, यह भौतिकी की दुनिया में भ्रमण को समाप्त करने का समय है। तथ्य यह है कि यह अभी भी एक लेख है, न कि एक बहु-पृष्ठ रिपोर्ट। यह अफ़सोस की बात है कि मेरे पास कई अन्य त्रुटियों के बारे में बात करने का समय नहीं था। जब आप पीवीएस-स्टूडियो डायग्नोस्टिक चेतावनियों के माध्यम से इस फाइल - geant4_old.txt पर नज़र डालते हैं, तो आप स्वयं को और अधिक विस्तार से संदिग्ध कोड से परिचित कर सकते हैं ।

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

और हां, जैसा कि मैं हमेशा दोहराता हूं, नियमित रूप से स्थिर कोड विश्लेषण का उपयोग करना अधिक कुशल है, और मामले से मामले में नहीं। नियमित उपयोग के महत्व को समझने के लिए, कृपया यहां और यहां पढ़ें।

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

केवल एक चीज जिसे मैं V636 और V624 के निदान को संक्षेप में बताना चाहता हूं। कभी-कभी वे गणनाओं में अशुद्धियों का संकेत दे सकते हैं। ऐसा लगता है कि कंप्यूटिंग कार्यक्रमों की बात आती है तो ये निदान महत्वपूर्ण हैं।

नैदानिक ​​उदाहरण V636:

 G4double G4XAqmTotal::CrossSection( const G4KineticTrack& trk1, const G4KineticTrack& trk2) const { .... G4int sTrk1 = ....; G4int qTrk1 = ....; G4double sRatio1 = 0.; if (qTrk1 != 0) sRatio1 = sTrk1 / qTrk1; .... } 

PVS- स्टूडियो चेतावनी: V636 'sTrk1 / qTrk1' की अभिव्यक्ति को 'int' प्रकार से 'डबल' प्रकार में निहित किया गया था। एक आंशिक भाग के नुकसान से बचने के लिए एक स्पष्ट प्रकार के कलाकारों का उपयोग करने पर विचार करें। एक उदाहरण: डबल ए = (डबल) (एक्स) / वाई ;; g4xaqmtotal.cc 103

विभाजन का परिणाम "डबल एक्स = 3/2" 1 है, 1.5 नहीं क्योंकि यह लापरवाही के कारण लग सकता है। शुरुआत में, पूर्णांक विभाजन होता है, और उसके बाद ही परिणाम 'डबल' प्रकार में बदल जाता है। अपरिचित कोड को देखते समय, यह कहना मुश्किल है कि क्या पूर्णांक विभाजन का वास्तव में उपयोग करने की आवश्यकता है या यह एक गलती है। मुझे लगता है कि Geant4 में ऐसी जगहें ध्यान देने योग्य हैं।

नोट। यदि पूर्णांक विभाजन की आवश्यकता है, तो ऐसे स्थानों को एक टिप्पणी के साथ होना चाहिए।

नैदानिक ​​उदाहरण V624:

 dSigPodT = HadrTot*HadrTot*(1+HadrReIm*HadrReIm)* (....)/16/3.1416*2.568; 

PVS-Studio चेतावनी: V624 निरंतर 3.1416 का उपयोग किया जा रहा है। परिणामी मूल्य गलत हो सकता है। <Math.h> से M_PI निरंतर का उपयोग करने पर विचार करें। g4elastichadrnucleushe.cc 750

यह स्पष्ट नहीं है कि कठिन स्थिरांक का उपयोग पाई, पाई / 2 और इसी तरह की संख्याओं को दर्शाने के लिए बड़े पैमाने पर किया जाता है। मैं यह मानने के लिए तैयार हूं कि सटीकता पर्याप्त है। लेकिन फिर भी, यह एक स्पष्टीकरण नहीं है। ऐसे स्थिरांक टाइपो और अशुद्धियों के लिए एक और कारण हैं। कई पूर्वनिर्धारित स्थिरांक हैं, जैसे कि M_PI, M_PI_4, M_LN2। पीवीएस-स्टूडियो कठोर स्थिरांक की जगह के लिए उपयुक्त सिफारिशें प्रदान करता है।

मैं लगभग भूल गया था। Geant4_old.txt फ़ाइल में , मैंने माइक्रो-ऑप्टिमाइज़ेशन से संबंधित संदेश भी दिए हैं। उदाहरण के लिए, पुनरावृत्तियों की वृद्धि के बारे में:

 class G4PhysicsTable : public std::vector<G4PhysicsVector*> { .... }; typedef G4PhysicsTable::iterator G4PhysicsTableIterator; inline void G4PhysicsTable::insertAt (....) { G4PhysicsTableIterator itr=begin(); for (size_t i=0; i<idx; ++i) { itr++; } .... } 

चेतावनी PVS-Studio: V803 प्रदर्शन में कमी। मामले में 'itr' इटरेटर है, यह वृद्धि के उपसर्ग रूप का उपयोग करने के लिए अधिक प्रभावी है। इसे पुनरावृत्ति ++ के साथ ++ पुनरावृत्ति बदलें। g4physicstable.icc 83

इसी प्रकार, यह क्यों बदल रहा है, यह लेख में वर्णित है: क्या उपसर्ग वृद्धि संचालक का उपयोग करना व्यावहारिक है + यह उपसर्ग के बजाय पुनरावृत्तियों के लिए इसे ++ ।

निष्कर्ष

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

संबंधित लिंक

1. एंड्रे कार्पोव। स्थैतिक विश्लेषण के बारे में मिथक। दूसरा मिथक यह है कि पेशेवर डेवलपर मूर्खतापूर्ण गलती नहीं करते हैं ।
2. एंड्रे कार्पोव। हमारे लेख पढ़ने के बाद अक्सर पूछे जाने वाले प्रश्नों के उत्तर ।
3. सी ++ भाषा, दिलचस्प लेख और हमारे द्वारा परीक्षण की गई परियोजनाओं की जानकारी के बारे में समाचार: @ कोड_अनलिसिस ।
4. विश्लेषक के साथ पहला परिचय: विज़ुअल सी ++ के लिए पीवीएस-स्टूडियो ।