🏆 🏑 🕺🏼 शून्य, एक, दो, फ्रेडी आपको उठाएंगे 👨🏿‍💼 👩🏿‍💼 🆒

यहां लेखों की एक श्रृंखला जारी है जिसे "प्रोग्रामर के लिए भयावहता" कहा जा सकता है। इस बार हम संख्या 0, 1, 2 के उपयोग से जुड़े एक विशिष्ट टाइपो पैटर्न के बारे में बात करेंगे। यदि आप C, C ++, C # या Java में लिखते हैं तो इससे कोई फर्क नहीं पड़ता। यदि आप स्थिरांक 0, 1, 2 का उपयोग करते हैं, या यदि ये संख्याएं चर नामों में समाहित हैं, तो सबसे अधिक संभावना है कि फ्रेडी आपको रात में आएंगे। पढ़ें और बाद में न कहें कि आपको चेतावनी नहीं दी गई थी।

परिचय

मैं पैटर्न पर लेखों की एक श्रृंखला जारी रखता हूं कि लोग कैसे गलतियाँ करते हैं। पिछले प्रकाशन:

इस बार पैटर्न मेरे द्वारा नहीं, बल्कि मेरे सहयोगी Svyatoslav Razmyslov द्वारा देखा गया था। उन्होंने इस तथ्य पर ध्यान आकर्षित किया कि वे अपने लेखों की समस्याओं में लगातार वर्णन करते हैं जिसमें चर 1 और 2 वाले चर उनके नाम पर दिखाई देते हैं। Svyatoslav ने सुझाव दिया कि मैं इस विषय का अधिक विस्तार से अध्ययन करता हूं और यह वास्तव में बहुत फलदायी निकला। यह पता चला है कि त्रुटियों के हमारे संग्रह में बड़ी संख्या में कोड टुकड़े होते हैं, जो इस तथ्य के कारण गलत होते हैं कि लोग 0, 1, 2 या ऐसे नंबरों वाले चर के नामों में भ्रमित हो जाते हैं। एक नई रोचक नियमितता सामने आई है, जिस पर नीचे चर्चा की जाएगी। इस विषय की जाँच करने और इस लेख को उन्हें समर्पित करने के लिए मैं Svyatoslav का आभारी हूँ।

Svyatoslav Razmyslov, प्रबंधक, चौकस बग कैचर और सिर्फ एक प्रतिभाशाली व्यक्ति।

इस लेख का उद्देश्य क्या है? दिखाओ कि हम सभी कितनी आसानी से गलतियाँ और टाइपो बनाते हैं। यदि प्रोग्रामर्स को चेतावनी दी जाती है, तो वे कोड समीक्षाओं की प्रक्रिया में अधिक चौकस होंगे, जो कि अशुभ 0, 1, 2 पर ध्यान केंद्रित करेंगे। इसके अलावा, प्रोग्रामर स्थिर कोड एनालाइज़र के मूल्य को महसूस करने में सक्षम होंगे जो ऐसी त्रुटियों को नोटिस करने में मदद करते हैं। यह पीवीएस-स्टूडियो विज्ञापन के बारे में नहीं है (हालांकि यह भी है :)। अब तक, कई प्रोग्रामर स्थैतिक विश्लेषण को बहुत अधिक पसंद करते हैं, अपनी सटीकता और कोड समीक्षाओं पर ध्यान केंद्रित करना पसंद करते हैं। दुर्भाग्य से, त्रुटियों के बिना कोड लिखने की कोशिश करना अच्छा है, लेकिन पर्याप्त नहीं है। यह लेख एक बार फिर इसे स्पष्ट रूप से प्रदर्शित करेगा।

ऐसी त्रुटियों से कोई भी प्रतिरक्षा नहीं करता है। नीचे आपको Qt, Clang, Hive, LibreOffice, लिनक्स कर्नेल, .NET कंपाइलर प्लेटफ़ॉर्म, XNU कर्नेल, मोज़िला फ़ायरफ़ॉक्स जैसी प्रसिद्ध परियोजनाओं में भी महाकाव्य ब्लूपर्स दिखाई देंगे। और ये कुछ विदेशी दुर्लभ त्रुटियाँ नहीं हैं, लेकिन सबसे अधिक लगातार हैं। आश्वस्त नहीं? तो चलिए शुरू करते हैं!

“चटर्जी बेकार है! मुझे कीड़े दिखाओ! ”

© लाइनस टोरवाल्ड्स द्वारा संशोधित उद्धरण।

जब अनुक्रमणिका अनुक्रमणिका में टाइपोस

एक नियम के रूप में, हमारे लेखों में हम चेतावनी देते हैं जिसकी मदद से त्रुटियां पाई जाती हैं। इस बार मैं इन चेतावनियों को छोड़ दूंगा, क्योंकि उनके बिना त्रुटि आसानी से ध्यान देने योग्य और समझने योग्य होगी। हालाँकि, इन त्रुटियों को कोड के एक छोटे टुकड़े में तुरंत स्पष्ट किया जाता है, लेकिन वे जानते हैं कि परियोजनाओं के कोड में कैसे छिपाना है।

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

एक्सएनयू कर्नेल परियोजना, सी भाषा

uint32_t
gss_krb5_3des_unwrap_mbuf(....)
{
  ....
  for (cflag = 1; cflag >= 0; cflag--) {
    *minor = gss_krb5_3des_token_get(
       ctx, &itoken, wrap, &hash, &offset, &length, reverse);
    if (*minor == 0)
      break;
    wrap.Seal_Alg[0] = 0xff;
    wrap.Seal_Alg[0] = 0xff;
  }
  ....
}

लाइन की प्रतिलिपि बनाई गई थी, लेकिन इंडेक्स को सही करना भूल गया। जैसा कि मैं इसे समझता हूं, इसे यहां लिखा जाना चाहिए:

wrap.Seal_Alg[0] = 0xff;
wrap.Seal_Alg[1] = 0xff;

लिब्रे ऑफिस प्रोजेक्ट, सी ++

Sequence< OUString > FirebirdDriver::
  getSupportedServiceNames_Static() throw (RuntimeException)
{
  Sequence< OUString > aSNS( 2 );
  aSNS[0] = "com.sun.star.sdbc.Driver";
  aSNS[0] = "com.sun.star.sdbcx.Driver";
  return aSNS;
}

जैसा कि पिछले मामले में, रेखा की नकल की गई थी, लेकिन 0 से 1 को ठीक करना भूल गया। केवल स्ट्रिंग शाब्दिक को सही किया गया था।

एक दार्शनिक सवाल पूछ सकता है, चार-पंक्ति फ़ंक्शन में कोई ऐसी गलती कैसे कर सकता है? सब संभव है। यहाँ यह है, प्रोग्रामिंग।

Quake-III-Arena परियोजना, सी भाषा

int VL_FindAdjacentSurface(....)
{
  ....
  if (fabs(dir[0]) > test->radius ||
      fabs(dir[1]) > test->radius ||
      fabs(dir[1]) > test->radius)
  {
  ....
}

प्रतिलिपि की गई पंक्ति में, वे dir [1] को dir [2] से बदलना भूल गए । परिणामस्वरूप, Z अक्ष के साथ मान नियंत्रित नहीं होता है।

OpenCOLLADA प्रोजेक्ट, C ++

struct short2
{
  short values[2];
  short2(short s1, short s2)
  {
    values[0] = s1;
    values[2] = s2;
  }
  ....
};

हां, इतने कम कंस्ट्रक्टर में भी, आप इसे आरंभीकृत होने पर किसी सरणी की सीमा से परे जाने का प्रबंधन कर सकते हैं।

गोडोट इंजन परियोजना, सी ++

Array PhysicsDirectSpaceState::_cast_motion(....)
{
  ....
  Array ret(true);
  ret.resize(2);
  ret[0]=closest_safe;
  ret[0]=closest_unsafe;
  return ret;
}

कोई टिप्पणी की आवश्यकता नहीं है।

तारांकन परियोजना, सी भाषा

static void sip_threadinfo_destructor(void *obj)
{
  struct sip_threadinfo *th = obj;
  struct tcptls_packet *packet;

  if (th->alert_pipe[1] > -1) {            // <=
    close(th->alert_pipe[0]);
  }
  if (th->alert_pipe[1] > -1) {
    close(th->alert_pipe[1]);
  }
  th->alert_pipe[0] = th->alert_pipe[1] = -1;
  ....
}

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

ओपन कैस्केड टेक्नोलॉजी प्रोजेक्ट, सी ++

inline void Prepend(const Standard_Integer theIndex)
{
  if (myIndex[1] >= 0)
    Standard_OutOfRange::Raise ("BRepMesh_PairOfIndex....");

  myIndex[1] = myIndex[0];
  myIndex[1] = theIndex;
}

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

myIndex[1] = myIndex[0];
myIndex[0] = theIndex;

ट्रांस-प्रोटीन पाइपलाइन परियोजना, सी ++

void ASAPRatio_getProDataStrct(proDataStrct *data,
                               char **pepBofFiles)
{
  ....
  if (data->indx == -1) {
    data->ratio[0] = -2.;
    data->ratio[0] = 0.;             // <=
    data->inv_ratio[0] = -2.;
    data->inv_ratio[1] = 0.;
    return;
  }
  ....
}

मुझे चिंता है कि अनुसंधान पैकेजों में ऐसी त्रुटियां हैं। ट्रांस-प्रोटीन पाइपलाइन को जीव विज्ञान के क्षेत्र में समस्याओं को हल करने के लिए डिज़ाइन किया गया है। यह तय किया जा सकता है और "जांच की जा सकती है।" इस पैकेज में आम तौर पर बहुत सारी दिलचस्प चीजें मिलती हैं: 2012 में चेक , 2013 की जांच करें । शायद आप फिर से इस परियोजना को देखने की कोशिश कर सकते हैं।

आईटीके परियोजना, सी ++ भाषा

हमें चिकित्सा के क्षेत्र में अनुसंधान करने के लिए एक और परियोजना का सामना करना पड़ रहा है: चिकित्सा अंतर्दृष्टि विभाजन और पंजीकरण टूलकिट (आईटीके)। परियोजना अलग है, लेकिन गलतियां समान हैं।

template< typename TCoordRepType >
void
VoronoiDiagram2D< TCoordRepType >::SetOrigin(PointType vorsize)
{
  m_VoronoiBoundaryOrigin[0] = vorsize[0];
  m_VoronoiBoundaryOrigin[0] = vorsize[1];
}

ITK प्रोजेक्ट, C ++


int itkPointSetToSpatialObjectDemonsRegistrationTest(....)
{
  ....
  // Set its position
  EllipseType::TransformType::OffsetType offset;
  offset[0]=50;
  offset[1]=50;
  offset[1]=50;
  ....
}

क्लीन कॉपी-पेस्ट।

रिएक्टोस प्रोजेक्ट, सी ++

HPALETTE CardWindow::CreateCardPalette()
{
  ....
  //include button text colours
  cols[0] = RGB(0, 0, 0);
  cols[1] = RGB(255, 255, 255);

  //include the base background colour
  cols[1] = crBackgnd;

  //include the standard button colours...
  cols[3] = CardButton::GetHighlight(crBackgnd);
  cols[4] = CardButton::GetShadow(crBackgnd);
  cols[5] = CardButton::GetFace(crBackgnd);
  ....
}

सबसे अधिक संभावना है, crBackgnd स्थिरांक को कोल सेल [2] को लिखा जाना चाहिए ।

कॉइन 3 डी प्रोजेक्ट, सी ++

SoVRMLInline::GLRender(SoGLRenderAction * action)
{
  ....
  if ((size[0] >= 0.0f && size[1] >= 0.0f && size[1] >= 0.0f) &&
      ((vis == ALWAYS) ||
       (vis == UNTIL_LOADED && child == NULL))) {
  ....
}

आकार [1] सरणी का तत्व दोहरा चेक किया गया है , और आकार [2] का तत्व चेक नहीं किया गया है। यह कैसे अजीब कलाकृतियों छवियों पर दिखाई देते हैं।

OpenCV प्रोजेक्ट, C ++

bool Jpeg2KDecoder::readHeader()
{
  ....
  cmptlut[0] = ....
  cmptlut[1] = ....
  cmptlut[2] = ....
  if( cmptlut[0] < 0 || cmptlut[1] < 0 || cmptlut[0] < 0 )
    result = false;
  ....
}

यह सीधे महसूस किया जाता है कि अभिव्यक्ति cmptlut [0] <0 को दो बार नकल करके नकल किया गया था, लेकिन केवल एक ही स्थान पर शून्य को सही किया।

विज़ुअलाइज़ेशन टूलकिट (वीटीके) प्रोजेक्ट, सी ++

void vtkImageStencilRaster::PrepareForNewData(....)
{
  ....
  if (allocateExtent &&
      allocateExtent[1] >= allocateExtent[1])
  ....
}

इसके बाद, मैं ऐसी कई त्रुटियों पर टिप्पणी नहीं करूंगा। टिप्पणी करने के लिए क्या है? ऐसे कोड अंशों को देखते समय मुख्य बात यह महसूस करना है कि हालांकि त्रुटि सरल है, इसका मतलब यह नहीं है कि यह प्रोग्रामर द्वारा देखा जाएगा।

विज़ुअलाइज़ेशन टूलकिट (वीटीके) प्रोजेक्ट, सी ++

template <class iterT>
void vtkDataSetAttributesCopyValues(....)
{
  ....
  inZPtr +=
    (outExt[0] - outExt[0])*inIncs[0] * data_type_size +
    (outExt[2] - outExt[2])*inIncs[1] * data_type_size +
    (outExt[4] - outExt[4])*inIncs[2] * data_type_size;
  ....
}

यहाँ, प्रोग्रामर स्पष्ट रूप से कोड लिखने की जल्दी में था। एक और तरीके से समझाना मुश्किल है कि कैसे उसने तीन बार गलती की। सरणी के तत्वों को खुद से घटाया जाता है। परिणाम यह है कि यह कोड समकक्ष है:

inZPtr +=
  (0)*inIncs[0] * data_type_size +
  (0)*inIncs[1] * data_type_size +
  (0)*inIncs[2] * data_type_size;

हालाँकि, इस कोड को और भी कम किया जा सकता है:

inZPtr += 0;

Sumptuously। कोड में एक लंबी, गंभीर दिखने वाली अभिव्यक्ति है, वास्तव में, कुछ भी नहीं करता है। मुझे ऐसे मामले बहुत पसंद हैं।

विज़ुअलाइज़ेशन टूलकिट (वीटीके) परियोजना, सी ++ भाषा

जल्दबाजी लेखन कोड का एक समान मामला।

void vtkPiecewiseControlPointsItem::SetControlPoint(
  vtkIdType index, double* newPos)
{
  double oldPos[4];
  this->PiecewiseFunction->GetNodeValue(index, oldPos);
  if (newPos[0] != oldPos[0] || newPos[1] != oldPos[1] ||
      newPos[2] != oldPos[2] || newPos[2] != oldPos[2])
    {
      this->PiecewiseFunction->SetNodeValue(index, newPos);
    }
}

तुलना न्यूपोस [2]! = ओल्डपोस [2] दो बार दोहराया जाता है ।

ADAPTIVE संचार पर्यावरण (ACE) परियोजना, C ++

bool URL_Base::strip_scheme (ACE_CString& url_string)
{
  ....
  ACE_CString::size_type pos = url_string.find (':');
  if (pos > 0 &&
      url_string[pos+1] == '/' &&
      url_string[pos+1] == '/')
  {
    ....
    // skip '<protocol>://'
    url_string = url_string.substr (pos+3);
  }
  ....
}

इस स्थिति को सत्यापित करना चाहिए कि बृहदान्त्र का सामना करने के बाद दो स्लैश। दूसरे शब्दों में, विकल्प ": //" खोजा गया है। एक टाइपो के कारण, चेक "अंधा" है और किसी भी चरित्र को दूसरे स्लैश के रूप में गिनने के लिए तैयार है।

आईपीपी नमूने परियोजना, सी ++

void MeBase::MakeVlcTableDecision()
{
  ....
  Ipp32s BestMV =
    IPP_MIN(IPP_MIN(m_cur.MvRate[0],m_cur.MvRate[1]),
                    IPP_MIN(m_cur.MvRate[2],m_cur.MvRate[3]));
  Ipp32s BestAC =
    IPP_MIN(IPP_MIN(m_cur.AcRate[0],m_cur.AcRate[1]),
                    IPP_MIN(m_cur.AcRate[2],m_cur.AcRate[2]));
  ....
}

मैक्रो को पास किए गए तर्कों में एक टाइपो यहां है:

IPP_MIN(m_cur.AcRate[2],m_cur.AcRate[2])

यह पता चला है कि न्यूनतम दो समान मूल्यों का चयन किया जाता है। वास्तव में, यह लिखा जाना चाहिए:

IPP_MIN(m_cur.AcRate[2],m_cur.AcRate[3])

वैसे, यह कोड मानक पुस्तकालय की उपयोगिता को प्रदर्शित कर सकता है। यदि आप इस तरह लिखते हैं:

Ipp32s BestMV = std::min_element(begin(m_cur.MvRate), end(m_cur.MvRate));
Ipp32s BestAC = std::min_element(begin(m_cur.AcRate), end(m_cur.AcRate));

यह कोड कम और त्रुटियों के लिए कम प्रवण हो जाएगा। दरअसल, एक ही प्रकार का कोड जितना कम होगा, उतनी ही सही ढंग से लिखे जाने की संभावना होगी।

प्रोजेक्ट ऑडेसिटी, सी ++

sampleCount VoiceKey::OnBackward (....) {
  ....
  int atrend = sgn(buffer[samplesleft - 2]-
                   buffer[samplesleft - 1]);
  int ztrend = sgn(buffer[samplesleft - WindowSizeInt-2]-
                   buffer[samplesleft - WindowSizeInt-2]);
  ....
}

सही अभिव्यक्ति है:

int ztrend = sgn(buffer[samplesleft - WindowSizeInt-2]-
                 buffer[samplesleft - WindowSizeInt-1]);

पीडीएफियम परियोजना, सी ++ भाषा

void sycc420_to_rgb(opj_image_t* img) {
  ....
  opj_image_data_free(img->comps[0].data);
  opj_image_data_free(img->comps[1].data);
  opj_image_data_free(img->comps[2].data);
  img->comps[0].data = d0;
  img->comps[1].data = d1;
  img->comps[2].data = d2;
  img->comps[1].w = yw;                 // 1
  img->comps[1].h = yh;                 // 1
  img->comps[2].w = yw;                 // 1
  img->comps[2].h = yh;                 // 1
  img->comps[1].w = yw;                 // 2
  img->comps[1].h = yh;                 // 2
  img->comps[2].w = yw;                 // 2
  img->comps[2].h = yh;                 // 2
  img->comps[1].dx = img->comps[0].dx;
  img->comps[2].dx = img->comps[0].dx;
  img->comps[1].dy = img->comps[0].dy;
  img->comps[2].dy = img->comps[0].dy;
}

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

सीएमके परियोजना, सी

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

static char *
utf8_encode(const wchar_t *wval)
{
  ....
  p[0] = 0xfc | ((wc >> 30) & 0x01);
  p[1] = 0x80 | ((wc >> 24) & 0x3f);
  p[1] = 0x80 | ((wc >> 18) & 0x3f);
  p[2] = 0x80 | ((wc >> 12) & 0x3f);
  p[3] = 0x80 | ((wc >> 6) & 0x3f);
  p[4] = 0x80 | (wc & 0x3f);
  p += 6;
  ....
}

जैसा कि आप देख सकते हैं, सूचकांक के साथ किसी तरह का भ्रम है। दो बार सरणी तत्व p [1] में एक रिकॉर्ड है । यदि आप पड़ोस में कोड का अध्ययन करते हैं, तो यह स्पष्ट हो जाता है कि सही कोड इस तरह होना चाहिए:

p[0] = 0xfc | ((wc >> 30) & 0x01);
p[1] = 0x80 | ((wc >> 24) & 0x3f);
p[2] = 0x80 | ((wc >> 18) & 0x3f);
p[3] = 0x80 | ((wc >> 12) & 0x3f);
p[4] = 0x80 | ((wc >> 6) & 0x3f);
p[5] = 0x80 | (wc & 0x3f);
p += 6;

नोट

कृपया ध्यान दें कि इस अध्याय में चर्चा की गई सभी त्रुटियां C या C ++ कोड से संबंधित हैं। कोई C # या जावा कोड!

यह बहुत दिलचस्प है, मुझे इसकी उम्मीद नहीं थी। मेरी राय में, माना गया टाइपो भाषा पर निर्भर नहीं है। और निम्नलिखित अध्यायों में, अन्य भाषाओं में कोड में त्रुटियां वास्तव में दिखाई देंगी। मुझे लगता है कि यह सिर्फ एक संयोग है। PVS-Studio विश्लेषक C / C ++ की तुलना में C # / Java भाषाओं का समर्थन करने के लिए बहुत बाद में शुरू हुआ, और हमने डेटाबेस में संबंधित त्रुटि उदाहरणों को संचित करने का प्रबंधन नहीं किया।

हालांकि, अवलोकन अभी भी दिलचस्प है। जाहिरा तौर पर, C और C ++ प्रोग्रामर सरणियों के साथ काम करते समय संख्या 0, 1 और 2 का उपयोग करना पसंद करते हैं :)।

नामों में गलतियाँ

यह सबसे बड़ा खंड होगा। लोगों के लिए a1 और a2 जैसे नामों से भ्रमित होना बहुत आसान है । ऐसा लगता है कि आप यहां भ्रमित हो सकते हैं? कर सकते हैं। आसान। और अब पाठक इसे सत्यापित कर सकेंगे।

हाइव प्रोजेक्ट, जावा

@Override
public List<ServiceInstance> getAllInstancesOrdered() {
  List<ServiceInstance> list = new LinkedList<>();
  list.addAll(instances.values());
  Collections.sort(list, new Comparator<ServiceInstance>() {
    @Override
    public int compare(ServiceInstance o1, ServiceInstance o2) {
      return o2.getWorkerIdentity().compareTo(o2.getWorkerIdentity());
    }
  });
  return list;
}

तुलना समारोह तुलना : दो वस्तुओं लेता O1 और O2 । लेकिन एक टाइपो के कारण, आगे केवल ओ 2 का उपयोग किया जाता है ।

दिलचस्प है, कॉपी-पेस्ट के लिए धन्यवाद, यह त्रुटि दूसरे फ़ंक्शन में माइग्रेट हुई:

@Override
public List<ServiceInstance> getAllInstancesOrdered() {
  List<ServiceInstance> list = new LinkedList<>();
  readLock.lock();
  try {
    list.addAll(instances.values());
  } finally {
    readLock.unlock();
  }
  Collections.sort(list, new Comparator<ServiceInstance>() {
    @Override
    public int compare(ServiceInstance o1, ServiceInstance o2) {
      return o2.getWorkerIdentity().compareTo(o2.getWorkerIdentity());
    }
  });
  return list;
}

Infer.NET प्रोजेक्ट, C # भाषा

private void MergeParallelTransitions()
{
  ....
  if (double.IsInfinity(transition1.Weight.Value) &&    
      double.IsInfinity(transition1.Weight.Value))
  ....
}

कयामत 3 परियोजना, सी ++

uint AltOp::fixedLength()
{
  uint l1 = exp1->fixedLength();
  uint l2 = exp1->fixedLength();

  if (l1 != l2 || l1 == ~0u)
    return ~0;

  return l1;
}

यदि किसी ने तुरंत एक टाइपो को नोटिस नहीं किया है, तो आपको उस पंक्ति को देखने की जरूरत है जहां एल 2 चर को आरंभीकृत किया गया है । Exp2 का उपयोग करना चाहिए ।

स्रोत इंजन एसडीके परियोजना, सी ++

void GetFPSColor( int nFps, unsigned char ucColor[3] )
{
  ....
  int nFPSThreshold1 = 20;
  int nFPSThreshold2 = 15;

  if (IsPC() &&
      g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 95)
  {
    nFPSThreshold1 = 60;
    nFPSThreshold1 = 50;
  }
  ....
}

सही ढंग से:

nFPSThreshold1 = 60;
nFPSThreshold2 = 50;

लिनक्स कर्नेल परियोजना, सी भाषा

वैसे, टाइपो न केवल चर नामों में हो सकता है, बल्कि मैक्रो नामों में भी हो सकता है। अब ऐसे कई उदाहरण होंगे।

int private_ioctl(struct vnt_private *pDevice, struct ifreq *rq)
{
  ....
  if (sStartAPCmd.byBasicRate & BIT3) {
    pMgmt->abyIBSSSuppRates[2] |= BIT7;
    pMgmt->abyIBSSSuppRates[3] |= BIT7;
    pMgmt->abyIBSSSuppRates[4] |= BIT7;
    pMgmt->abyIBSSSuppRates[5] |= BIT7;
  } else if (sStartAPCmd.byBasicRate & BIT2) {
    pMgmt->abyIBSSSuppRates[2] |= BIT7;
    pMgmt->abyIBSSSuppRates[3] |= BIT7;
    pMgmt->abyIBSSSuppRates[4] |= BIT7;
  } else if (sStartAPCmd.byBasicRate & BIT1) {  // <=
    pMgmt->abyIBSSSuppRates[2] |= BIT7;
    pMgmt->abyIBSSSuppRates[3] |= BIT7;
  } else if (sStartAPCmd.byBasicRate & BIT1) {  // <=
    pMgmt->abyIBSSSuppRates[2] |= BIT7;
  } else {
    /* default 1,2M */
    pMgmt->abyIBSSSuppRates[2] |= BIT7;
    pMgmt->abyIBSSSuppRates[3] |= BIT7;
  }
  ....
}

जैसा कि आप देख सकते हैं, BIT1 नामक एक मास्क का दो बार उपयोग किया जाता है , जो दूसरे चेक को बेकार कर देता है। दूसरे टिप्पणी वाले सशर्त विवरण के निकाय को कभी निष्पादित नहीं किया जाएगा।

CMaNGOS प्रोजेक्ट, C ++

void AttackedBy(Unit* pAttacker) override
{
  ....
  DoScriptText(urand(0, 1) ?
               SAY_BELNISTRASZ_AGGRO_1 :
               SAY_BELNISTRASZ_AGGRO_1,
               m_creature, pAttacker);
  ....
}

खेल में यादृच्छिक व्यवहार की योजना बनाई गई थी, लेकिन हमेशा उसी SAY_BELNISTRASZ_AGGRO_1 का चयन किया जाता है ।

वैंगर्स प्रोजेक्ट: वन फॉर द रोड, C ++

const char* iGetJoyBtnNameText(int vkey,int lang)
{
  ....
  if (vkey >= VK_STICK_SWITCH_1 && vkey <= VK_STICK_SWITCH_9)
  {
     ret = (lang)
      ? iJoystickStickSwitch2[vkey - VK_STICK_SWITCH_1]
      : iJoystickStickSwitch2[vkey - VK_STICK_SWITCH_1];
    return ret;
  }
  ....
}

इसके आगे लिखे कोड को देखते हुए, सही विकल्प इस तरह होना चाहिए:

ret = (lang)
  ? iJoystickStickSwitch2[vkey - VK_STICK_SWITCH_1]
  : iJoystickStickSwitch1[vkey - VK_STICK_SWITCH_1];

आरटी-थ्रेड प्रोजेक्ट, सी भाषा

uint8_t can_receive_message_length(uint32_t can_periph,
                                   uint8_t fifo_number)
{
  uint8_t val = 0U;

  if(CAN_FIFO0 == fifo_number){
    val = (uint8_t)(CAN_RFIFO0(can_periph) & CAN_RFIFO_RFL0_MASK);
  }else if(CAN_FIFO0 == fifo_number){
    val = (uint8_t)(CAN_RFIFO1(can_periph) & CAN_RFIFO_RFL0_MASK);
  }else{
    /* illegal parameter */
  }
  return val;
}

आरटी-थ्रेड एम्बेडेड उपकरणों के लिए एक ओपन-सोर्स, रीयल-टाइम ऑपरेटिंग सिस्टम है। यहाँ हम FIFO 0 और FIFO 1 के बीच का भ्रम देखते हैं। और कहीं न कहीं, किसी को एक छोटी गाड़ी का सामना करना पड़ेगा।

त्रुटि यहाँ है:

if      (CAN_FIFO0 == fifo_number){
....
}else if(CAN_FIFO0 == fifo_number){

दूसरा चेक हमेशा गलत देता है। सही ढंग से:

if      (CAN_FIFO0 == fifo_number){
....
}else if(CAN_FIFO1 == fifo_number){

हाइव प्रोजेक्ट, जावा

private void
generateDateTimeArithmeticIntervalYearMonth(String[] tdesc) throws Exception {
  String operatorName = tdesc[1];
  String operatorSymbol = tdesc[2];
  String operandType1 = tdesc[3];
  String colOrScalar1 = tdesc[4];
  String operandType2 = tdesc[5];
  String colOrScalar2 = tdesc[6];
  ....
  if (colOrScalar1.equals("Col") && colOrScalar1.equals("Column")) {
    ....
  } else if (colOrScalar1.equals("Col") && colOrScalar1.equals("Scalar")) {
    ....
}

PVS- स्टूडियो विश्लेषक तुरंत 2 त्रुटियों को इंगित करता है:

ColOrScalar1 में संग्रहीत स्ट्रिंग, Col और Column स्ट्रिंग्स दोनों को बराबर नहीं कर सकती है;
ColOrScalar1 में संग्रहित स्ट्रिंग एक ही समय में Col और Scalar तार की बराबरी नहीं कर सकती है।

चर नामों के बारे में स्पष्ट रूप से भ्रम है।

Shareaza परियोजना, C ++ भाषा

void CDownloadWithSources::MergeMetadata(const CXMLElement* pXML)
{
  CQuickLock pLock( Transfers.m_pSection );

  CXMLAttribute* pAttr1 =
    m_pXML->GetAttribute(CXMLAttribute::schemaName);
  CXMLAttribute* pAttr2 =
    pXML->GetAttribute(CXMLAttribute::schemaName);

  if (pAttr1 && pAttr2 &&
      !pAttr1->GetValue().CompareNoCase(pAttr1->GetValue()))
    ....
}

सही ढंग से:

pAttr1->GetValue().CompareNoCase(pAttr2->GetValue())

नोट

चलिए एक छोटा विराम लेते हैं। एक डर है कि प्रतिबंधात्मक गलतियों का पहाड़ देखकर हम भूल जाएंगे कि हम ऐसा क्यों कर रहे हैं।

कार्य किसी और के कोड पर हंसना नहीं है। यह सब आपकी उंगली को दबाने और कहने का कारण नहीं है: "हा हा, ठीक है, आपको करना होगा।" यह सोचने का कारण! हमारी टीम के

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

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

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

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

Qt प्रोजेक्ट, C ++

AtomicComparator::ComparisonResult
IntegerComparator::compare(const Item &o1,
                           const AtomicComparator::Operator,
                           const Item &o2) const
{
  const Numeric *const num1 = o1.as<Numeric>();
  const Numeric *const num2 = o1.as<Numeric>();

  if(num1->isSigned() || num2->isSigned())
  ....
}

सही ढंग से:

const Numeric *const num2 = o2.as<Numeric>();

Android प्रोजेक्ट, C ++ भाषा

static inline bool isAudioPlaybackRateEqual(
  const AudioPlaybackRate &pr1,
  const AudioPlaybackRate &pr2)
{
    return fabs(pr1.mSpeed - pr2.mSpeed) <
             AUDIO_TIMESTRETCH_SPEED_MIN_DELTA &&
           fabs(pr1.mPitch - pr2.mPitch) <
             AUDIO_TIMESTRETCH_PITCH_MIN_DELTA &&
           pr2.mStretchMode == pr2.mStretchMode &&
           pr2.mFallbackMode == pr2.mFallbackMode;
}

एक साथ दो टाइपो, जिसके कारण चर pr2.mStretchMode और pr2.mFallbackMode की तुलना खुद से की जाती है।

बूस्ट प्रोजेक्ट, सी ++

point3D operator/(const point3D &p1, const point3D &p2)
{
  return point3D(p1.x/p2.x, p1.y/p2.y, p1.z/p1.z);
}

बहुत अंत में, उन्होंने अपने आप को चर p1.z विभाजित किया।

क्लैंग प्रोजेक्ट, सी ++

bool haveSameType(QualType Ty1, QualType Ty2) {
  return (Context.getCanonicalType(Ty1) ==
          Context.getCanonicalType(Ty2) ||
          (Ty2->isIntegerType() &&
           Ty2->isIntegerType()));
}

हां, हां, पीवीएस-स्टूडियो विश्लेषक कंपाइलरों में समान त्रुटियां पाता है। सही ढंग से:

(Ty1->isIntegerType() &&
 Ty2->isIntegerType())

क्लैंग प्रोजेक्ट, सी ++

Instruction *InstCombiner::visitXor(BinaryOperator &I) {
  ....
  if (Op0I && Op1I && Op0I->isShift() &&
      Op0I->getOpcode() == Op1I->getOpcode() &&
      Op0I->getOperand(1) == Op1I->getOperand(1) &&
      (Op1I->hasOneUse() || Op1I->hasOneUse())) {
  ....
}

सही ढंग से:

(Op0I->hasOneUse() || Op1I->hasOneUse())

Qt प्रोजेक्ट, C ++

inline bool qCompare(QImage const &t1, QImage const &t2, ....)
{
  ....
  if (t1.width() != t2.width() || t2.height() != t2.height()) {
  ....
}

NCBI जीनोम कार्यक्षेत्र परियोजना, C ++

static bool s_PCRPrimerSetLess(const CPCRPrimerSet& s1, const CPCRPrimerSet& s2)
{
  if (!s1.IsSet() && s1.IsSet()) {
    return true;
  } else if (s1.IsSet() && !s2.IsSet()) {
    return false;
  } else if (!s1.IsSet() && !s2.IsSet()) {
    return false;
  } else if (s1.Get().size() < s2.Get().size()) {
    return true;
  } else if (s1.Get().size() > s2.Get().size()) {
    return false;
  } else {
  .....
}

पहले चेक में त्रुटि। यह लिखा जाना चाहिए:

if (!s1.IsSet() && s2.IsSet()) {

NCBI जीनोम कार्यक्षेत्र परियोजना, C ++

CRef<CSeq_align> CNWAligner::Run(CScope &scope, const CSeq_loc &loc1,
                                 const CSeq_loc &loc2, bool trim_end_gaps)
{
  if ((!loc1.IsInt() && !loc1.IsWhole()) ||
      (!loc1.IsInt() && !loc1.IsWhole()))
  {
    NCBI_THROW(CException, eUnknown,
               "Only whole and interval locations supported");
  }
  ....
}

स्थिति की पहली पंक्ति को प्रचारित किया गया था, लेकिन फिर प्रोग्रामर ने जल्दबाज़ी की और loc2 को loc2 से बदलना भूल गया ।

FlashDevelop परियोजना, सी #

public void SetPrices(....)
{
  UInt32 a0 = _choice.GetPrice0();
  UInt32 a1 = _choice.GetPrice1();
  UInt32 b0 = a1 + _choice2.GetPrice0();   // <=
  UInt32 b1 = a1 + _choice2.GetPrice1();
  ....
}

FreeCAD प्रोजेक्ट, C ++

inline void insEdgeVec(std::map<int,std::set<int> > &map,
                       int n1, int n2)
{
  if(n1<n2)
    map[n2].insert(n1);
  else
    map[n2].insert(n1);
};

शर्त के बावजूद, एक ही कार्रवाई की जाती है। यह इतना आसान मामला होगा। आप एक पंक्ति की प्रतिलिपि कैसे बना सकते हैं और इसे ठीक नहीं कर सकते हैं? कर सकते हैं।

लिब्रे ऑफिस प्रोजेक्ट, सी ++

class SVX_DLLPUBLIC SdrMarkView : public SdrSnapView
{
  ....
  const Point& GetRef1() const { return maRef1; }
  const Point& GetRef2() const { return maRef1; }
  ....
};

क्लासिकल कॉपी-पेस्ट त्रुटि। सही ढंग से:

const Point& GetRef2() const { return maRef2; }

लिब्रे ऑफिस प्रोजेक्ट, सी ++

bool CmpAttr(
  const SfxPoolItem& rItem1, const SfxPoolItem& rItem2)
{
  ....
  ::boost::optional<sal_uInt16> oNumOffset1 =
        static_cast<const SwFmtPageDesc&>(rItem1).GetNumOffset();
  ::boost::optional<sal_uInt16> oNumOffset2 =
        static_cast<const SwFmtPageDesc&>(rItem1).GetNumOffset();
  ....
}

और एक और क्लासिक कॉपी-पेस्ट त्रुटि :)। एक जगह 1 से 2 सही हो गए, और दूसरे में वे भूल गए।

लिब्रे ऑफिस प्रोजेक्ट, सी ++

XMLTransformerOOoEventMap_Impl::XMLTransformerOOoEventMap_Impl(
        XMLTransformerEventMapEntry *pInit,
        XMLTransformerEventMapEntry *pInit2 )
{
  if( pInit )
    AddMap( pInit );
  if( pInit )
    AddMap( pInit2 );
}

1 को 2 के साथ बदलने में कोई गलती नहीं है, लेकिन सिर्फ 2 को दूसरी स्थिति में नहीं जोड़ा गया है।

आप थोड़े थके हुए हो सकते हैं। इसलिए, मैं चाय या कॉफी बनाने का प्रस्ताव करता हूं, और हम संख्या 0, 1 और 2 की दुनिया के साथ अपने परिचितों को जारी रखेंगे।

Geant4 सॉफ्टवेयर प्रोजेक्ट, C ++ भाषा

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];
  }
  ....
}

मुझे आशा है कि आपने सलाह ली और आराम किया। इस कोड में कोई त्रुटि खोजने के लिए तैयार हैं?

उन पाठकों को बधाई, जिन्होंने गलती देखी है। तुम महान हो!

जो खोज करने में बहुत आलसी हैं, मैं उन लोगों को भी समझता हूं। इस तरह के कोड की समीक्षा बहुत थकाऊ है और किसी भी तरह जल्दी से कुछ और दिलचस्प की जांच करने की इच्छा है। यह वह जगह है जहाँ स्थैतिक विश्लेषक बहुत मदद करते हैं क्योंकि वे थकते नहीं हैं।

त्रुटि यह है कि ये दोनों चेक समान हैं:

if        (areacode & sC0Min1Max) {
} else if (areacode & sC0Min1Max) {

यदि आप कोड का अध्ययन करते हैं, तो यह स्पष्ट हो जाता है कि बहुत पहले चेक गलत है। सही ढंग से:

if        (areacode & sC0Min1Min) {
} else if (areacode & sC0Max1Min) {
} else if (areacode & sC0Max1Max) {
} else if (areacode & sC0Min1Max) {

क्रिअर्जाइन वी प्रोजेक्ट, सी ++

bool
CompareRotation(const Quat& q1, const Quat& q2, float epsilon)
{
  return (fabs_tpl(q1.v.x - q2.v.x) <= epsilon)
      && (fabs_tpl(q1.v.y - q2.v.y) <= epsilon)
      && (fabs_tpl(q2.v.z - q2.v.z) <= epsilon) // <=
      && (fabs_tpl(q1.w - q2.w) <= epsilon);
}

TortoiseGit प्रोजेक्ट, C ++

void CGitStatusListCtrl::OnContextMenuList(....)
{
  ....
  if( (!this->m_Rev1.IsEmpty()) ||
      (!this->m_Rev1.IsEmpty()) )
  ....
}

Geant4 सॉफ्टवेयर प्रोजेक्ट, C ++ भाषा

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;
  ....
}

मोनोडेवलप प्रोजेक्ट, सी #

private bool MembersMatch(ISymbol member1, ISymbol member2)
{
  ....
  if (member1.DeclaredAccessibility !=
      member1.DeclaredAccessibility
   || member1.IsStatic != member1.IsStatic)
  {
    return false;
  }
  ....
}

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

डॉल्फिन एमुलेटर प्रोजेक्ट, सी ++

bool IRBuilder::maskedValueIsZero(InstLoc Op1, InstLoc Op2) const
{
  return (~ComputeKnownZeroBits(Op1) &
          ~ComputeKnownZeroBits(Op1)) == 0;
}

RunAsAdmin एक्सप्लोरर शिम परियोजना, C ++

bool IsLuidsEqual(LUID luid1, LUID luid2)
{
  return (luid1.LowPart == luid2.LowPart) &&
         (luid2.HighPart == luid2.HighPart);
}

IT ++ प्रोजेक्ट, C ++ भाषा

Gold::Gold(const ivec &mseq1_connections,
           const ivec &mseq2_connections)
{
  ....
  it_assert(mseq1.get_length() == mseq1.get_length(),
            "Gold::Gold(): dimension mismatch");
}

क्वांटलिब प्रोजेक्ट, सी ++

Distribution ManipulateDistribution::convolve(
  const Distribution& d1, const Distribution& d2) {
  ....
  QL_REQUIRE (d1.xmin_ == 0.0 && d1.xmin_ == 0.0,
              "distributions offset larger than 0");
  ....
}

सांबा प्रोजेक्ट, सी ++

static bool samu_correct(struct samu *s1, struct samu *s2)
{
  ....
  } else if (s1_len != s1_len) {
    DEBUG(0, ("Password history not written correctly, "
              "lengths differ, want %d, got %d\n",
          s1_len, s2_len));
  ....
}

मोज़िला फ़ायरफ़ॉक्स प्रोजेक्ट, सी ++

static PRBool IsZPositionLEQ(nsDisplayItem* aItem1,
                             nsDisplayItem* aItem2,
                             void* aClosure) {
  if (!aItem1->GetUnderlyingFrame()->Preserves3D() ||
      !aItem1->GetUnderlyingFrame()->Preserves3D()) {
    return IsContentLEQ(aItem1, aItem2, aClosure);
  }
  ....
}

हाइकु ऑपरेशन सिस्टम प्रोजेक्ट, सी ++

void trans_double_path::reset()
{
  m_src_vertices1.remove_all();
  m_src_vertices2.remove_all();
  m_kindex1 = 0.0;               // <=
  m_kindex1 = 0.0;               // <=
  m_status1 = initial;
  m_status2 = initial;
}

Qt प्रोजेक्ट, C ++

Ok, अब थोड़ा और जटिल हो गया है। मज़े के लिए, यहाँ त्रुटि खोजने की कोशिश करें:

static ShiftResult shift(....)
{
  ....
  qreal l = (orig->x1 - orig->x2)*(orig->x1 - orig->x2) +
            (orig->y1 - orig->y2)*(orig->y1 - orig->y1) *
            (orig->x3 - orig->x4)*(orig->x3 - orig->x4) +
            (orig->y3 - orig->y4)*(orig->y3 - orig->y4);
  ....
}

एक तस्वीर, इसलिए तुरंत जवाब देखने के लिए नहीं, और सोचने का अवसर मिला।

यह सही है, इसके बजाय उत्पत्ति-> y1 - मूल-> y1 को मूल लिखा जाना चाहिए-> y1 - मूल-> y2 ।

.NET कंपाइलर प्लेटफ़ॉर्म प्रोजेक्ट, C # भाषा

public void IndexerMemberRace()
{
  ....
  for (int i = 0; i < 20; i++)
  {
    ....
    if (i % 2 == 0)
    {
      thread1.Start();
      thread2.Start();
    }
    else
    {
      thread1.Start();
      thread2.Start();
    }
    ....
  }
  ....
}

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

सही ढंग से:

if (i % 2 == 0)
{
  thread1.Start();
  thread2.Start();
}
else
{
  thread2.Start();
  thread1.Start();
}

सांबा प्रोजेक्ट, सी भाषा

static int compare_procids(const void *p1, const void *p2)
{
  const struct server_id *i1 = (struct server_id *)p1;
  const struct server_id *i2 = (struct server_id *)p2;

  if (i1->pid < i2->pid) return -1;
  if (i2->pid > i2->pid) return 1;
  return 0;
}

तुलना समारोह 1 कभी नहीं लौटेगा, क्योंकि i2-> pid> i2-> pid का कोई मतलब नहीं है।

स्वाभाविक रूप से, यह एक सामान्य टाइपो है, और वास्तव में इसे लिखा जाना चाहिए:

if (i1->pid > i2->pid) return 1;

चक्रचोर परियोजना, C ++

इस अध्याय का अंतिम मामला। हुर्रे!

bool Lowerer::GenerateFastBrSrEq(....,
                                 IR::RegOpnd * srcReg1,
                                 IR::RegOpnd * srcReg2,
                                 ....)
{
  ....
  else if (srcReg1 && (srcReg1->m_sym->m_isStrConst))
  ....
  else if (srcReg1 && (srcReg1->m_sym->m_isStrConst))
  ....
}

अन्य त्रुटियां

अब संख्या 0, 1, 2 के उपयोग से जुड़े कम त्रुटि वाले पैटर्न के बारे में बात करते हैं।

उन स्थितियों में टाइप करें जहां स्थिर 0/1/2 का स्पष्ट रूप से उपयोग किया जाता है

रूट प्रोजेक्ट, C ++

Int_t TProofMonSenderML::SendSummary(TList *recs, const char *id)
{
  ....
  if (fSummaryVrs == 0) {
    if ((dsn = recs->FindObject("dataset"))) recs->Remove(dsn);
  } else if (fSummaryVrs == 0) {
  ....
}

यह अजीब है fSummaryVrs की तुलना में 0. दो बार ।

.NET CoreCLR प्रोजेक्ट, C #

void PutIA64Imm22(UINT64 * pBundle, UINT32 slot, INT32 imm22)
{
  if (slot == 0)             // <=
  {
    ....
  }
  else if (slot == 1)
  {
    ....
  }
  else if (slot == 0)        // <=
  {
    .... 
  }
  ....
}

FFmpeg प्रोजेक्ट, सी भाषा

static int imc_decode_block(....)
{
  ....
  if (stream_format_code & 0x1)
    imc_decode_level_coefficients_raw(....);
  else if (stream_format_code & 0x1)
    imc_read_level_coeffs_raw(....);
  ....
}

जिप / नाम

पहले हमने ऐसे मामलों पर विचार किया था जब सूचकांक या नाम गलत है। और यहाँ एक स्थिति है जहाँ आपने तुरंत यह नहीं बताया कि त्रुटि को कैसे वर्गीकृत किया जाए। इस उदाहरण को एक और दूसरे अध्याय दोनों के लिए जिम्मेदार ठहराया जा सकता है। इसलिए, मैंने इसे अलग से लाने का फैसला किया।

मेसा 3 डी ग्राफिक्स लाइब्रेरी प्रोजेक्ट, सी ++

bool
ir_algebraic_visitor::reassociate_constant(....)
{
  ....
  if (ir1->operands[0]->type->is_matrix() ||
      ir1->operands[0]->type->is_matrix() ||
      ir2->operands[1]->type->is_matrix() ||
      ir2->operands[1]->type->is_matrix())
   return false;
  ....
}

यह कोड इस तरह तय किया जा सकता है:

if (ir1->operands[0]->type->is_matrix() ||
    ir1->operands[1]->type->is_matrix() ||
    ir2->operands[0]->type->is_matrix() ||
    ir2->operands[1]->type->is_matrix())

और आप इसे इस तरह से ठीक कर सकते हैं:

if (ir1->operands[0]->type->is_matrix() ||
    ir2->operands[0]->type->is_matrix() ||
    ir1->operands[1]->type->is_matrix() ||
    ir2->operands[1]->type->is_matrix())

अतिरिक्त 0

कभी-कभी 0 बेमानी और हानिकारक होता है। इसकी वजह से संख्या ऑक्टल में बदल सकती है जहां इसकी जरूरत नहीं है। या स्वरूप स्ट्रिंग को खराब करें।

उल्लिखित त्रुटियां इस लेख के लिए उपयुक्त नहीं हैं, लेकिन मुझे लगता है कि यह उनके उल्लेख के लायक है। मैं लेख में इन त्रुटियों के साथ एक कोड नहीं दूंगा, लेकिन अगर दिलचस्पी है, तो आप उन्हें यहां देख सकते हैं:

V536 सलाह दी जाती है कि उपयोग किए गए स्थिर मूल्य को एक अष्टाधारी रूप, उदाहरणों द्वारा दर्शाया जाए ;
V638 एक टर्मिनल नल एक स्ट्रिंग के अंदर मौजूद है। '\ 0xNN' वर्णों का सामना किया गया। शायद इसका मतलब है: '\ xNN', उदाहरण ।

+1 लिखना भूल गए

हाइकु ऑपरेशन सिस्टम प्रोजेक्ट, सी ++

int
UserlandFS::KernelEmu::new_path(const char *path, char **copy)
{
  ....
  // append a dot, if desired
  if (appendDot) {
    copiedPath[len] = '.';
    copiedPath[len] = '\0';
  }
  ....
}

सही विकल्प:

copiedPath[len] = '.';
copiedPath[len + 1] = '\0';

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

स्वरूपण त्रुटियां (C #)

अधिकतर, स्ट्रिंग्स के निर्माण के लिए कार्य कम संख्या में तर्कों के साथ काम करते हैं। तो यह पता चला है कि अक्सर त्रुटियां {0}, {1} या {2} के उपयोग से जुड़ी होती हैं।

Azure पॉवरशेल प्रोजेक्ट, C #

protected override void ProcessRecordInternal()
{
  ....
  if (this.ShouldProcess(this.Name,
    string.Format("Creating Log Alert Rule '{0}' in resource group {0}",
      this.Name, this.ResourceGroupName)))
  {
    ....
  }
  ....
}

दो बार लिखा और {0} लिखा। नतीजतन, यह नाम.नाम दो बार स्ट्रिंग में डाला जाएगा । लेकिन यह नाम। RourceGroupName निर्मित स्ट्रिंग में नहीं मिलेगा।

मोनो परियोजना, सी #

void ReadEntropy ()
{
  if (reader.IsEmptyElement)
    throw new XmlException (
      String.Format ("WS-Trust Entropy element is empty.{2}",
                      LineInfo ()));
  ....
}

यह आमतौर पर अजीब है। आपको वह सम्मिलित करना होगा जो नहीं है। सबसे अधिक संभावना है, यह कोड असफल रिफैक्टिंग से गुजर गया और टूट गया।

Xenko प्रोजेक्ट, C #

public string ToString(string format,
                                IFormatProvider formatProvider)
{
  if (format == null)
    return ToString(formatProvider);

  return string.Format(
                      formatProvider,
                      "Red:{1} Green:{2} Blue:{3}",
                      R.ToString(format, formatProvider),
                      G.ToString(format, formatProvider),
                      B.ToString(format, formatProvider));
}

प्रोग्रामर यह भूल गया कि नंबरिंग {0} से शुरू होती है, {1} से नहीं। सही कोड है:

return string.Format(
                    formatProvider,
                    "Red:{0} Green:{1} Blue:{2}",
                    R.ToString(format, formatProvider),
                    G.ToString(format, formatProvider),
                    B.ToString(format, formatProvider));

.NET कंपाइलर प्लेटफ़ॉर्म प्रोजेक्ट, C #

private void DumpAttributes(Symbol s)
{
  ....
  Console.WriteLine("{0} {1} {2}", pa.ToString());
  ....
}

तर्क स्पष्ट रूप से पर्याप्त नहीं हैं।

निष्कर्ष और सिफारिशें

मुझे 0, 1 और 2 से संबंधित टाइपोस दिखाने के लिए बहुत सारे उदाहरण प्रदर्शित करने थे।

अगर मैंने बस कहा: "ओ 1 और ओ 2 को भ्रमित करना आसान है," आप सहमत होंगे, लेकिन इसका अर्थ यह नहीं है कि आप लेख के माध्यम से पढ़कर या कम से कम स्क्रॉल करके अब संलग्न करें।

अब आपको चेतावनी दी गई है, और यह अच्छा है। सचेत सबल होता है। अब आप कोड समीक्षाओं के लिए अधिक चौकस होंगे और चर पर अतिरिक्त ध्यान देंगे, जिनके नाम पर आप 0, 1, 2 देखेंगे

। ऐसी त्रुटियों से बचने के लिए कोड को कैसे डिज़ाइन किया गया है, इस पर कुछ सिफारिशें देना मुश्किल है। जैसा कि आपने देखा है, ऐसे सरल कोड में भी त्रुटियां पाई जाती हैं, जहां कुछ भी जारी नहीं होता है।

इसलिए, मैं आपसे 0, 1, 2 से बचने और चर नाम लंबे समय देने का आग्रह नहीं करूंगा। यदि आप संख्याओं के बजाय फर्स्ट / सेकंड / लेफ्ट / राइट वगैरह लिखना शुरू करते हैं, तो नाम या अभिव्यक्ति की प्रतिलिपि बनाने का प्रलोभन और भी बड़ा होगा। शायद ऐसी सिफारिश अंततः कम नहीं होगी, लेकिन त्रुटियों की संख्या में वृद्धि होगी।

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

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

ध्यान देने के लिए आपको धन्यवाद। मुझे आशा है कि आप रुचि रखते थे और डरे हुए थे। मैं आपको 0, 1, 2 के साथ एक विश्वसनीय कोड और कम त्रुटि की कामना करता हूं, ताकि फ्रेडी आपके पास न आए।

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

शून्य, एक, दो, फ्रेडी आपको उठाएंगे

परिचय

जब अनुक्रमणिका अनुक्रमणिका में टाइपोस

नामों में गलतियाँ

अन्य त्रुटियां

उन स्थितियों में टाइप करें जहां स्थिर 0/1/2 का स्पष्ट रूप से उपयोग किया जाता है

जिप / नाम

अतिरिक्त 0

+1 लिखना भूल गए

स्वरूपण त्रुटियां (C #)

निष्कर्ष और सिफारिशें

More articles: