मैं "हस्ताक्षरित / अहस्ताक्षरित बेमेल" चेतावनी (C4018) से कैसे निपटूं?

Question 1

मैं C ++ में उच्च प्रदर्शन और कम मेमोरी ओवरहेड को ध्यान में रखते हुए बहुत सारे गणना कोड के साथ काम करता हूं। यह एसटीएल कंटेनरों (ज्यादातर vector) का उपयोग करता है , और लगभग हर एक फ़ंक्शन में उस कंटेनरों पर पुनरावृत्त करता है।

पुनरावृति कोड इस तरह दिखता है:

for (int i = 0; i < things.size(); ++i)
{
    // ...
}

लेकिन यह हस्ताक्षरित / अहस्ताक्षरित बेमेल चेतावनी (विजुअल स्टूडियो में C4018) का उत्पादन करता है ।

intकुछ unsignedप्रकार के साथ बदलना एक समस्या है क्योंकि हम अक्सर ओपनएमपी प्रैग्मैस का उपयोग करते हैं, और इसके लिए काउंटर की आवश्यकता होती है int।

मैं (सैकड़ों) चेतावनियों को दबाने वाला हूं, लेकिन मुझे डर है कि मैंने समस्या के कुछ सुरुचिपूर्ण समाधान को याद किया है।

पुनरावृत्तियों पर । मुझे लगता है कि उपयुक्त स्थानों पर लागू होने पर पुनरावृत्तियाँ महान हैं। मैं जिस कोड के साथ काम कर रहा हूं, वह कभी भी रैंडम-एक्सेस कंटेनरों को listया कुछ में नहीं बदलेगा (इसलिए int iपहले से ही कंटेनर एग्नॉस्टिक है), और हमेशा वर्तमान सूचकांक की आवश्यकता होगी । और सभी अतिरिक्त कोड आपको टाइप करने की आवश्यकता होती है (इट्रेटर ही और इंडेक्स) बस मामलों को उलझाते हैं और अंतर्निहित कोड की सादगी को बाधित करते हैं।

Question 2

यह आपके things.size()प्रकार में है। यह नहीं है int, लेकिन size_t(यह C ++ में मौजूद है, C में मौजूद नहीं है) जो unsigned intx86-32 के लिए कुछ "सामान्य" अहस्ताक्षरित प्रकार के बराबर है।

ऑपरेटर "कम" (<) अलग संकेत के दो ऑपरेंड पर लागू नहीं किया जा सकता है। बस ऐसा कोई ऑपकोड नहीं है, और मानक निर्दिष्ट नहीं करता है, चाहे संकलक अंतर्निहित संकेत रूपांतरण कर सकता है। तो यह सिर्फ हस्ताक्षर किए गए नंबर को अहस्ताक्षरित मानता है और उस चेतावनी का उत्सर्जन करता है।

इसे लिखना सही होगा

for (size_t i = 0; i < things.size(); ++i) { /**/ }

या इससे भी तेज

for (size_t i = 0, ilen = things.size(); i < ilen; ++i) { /**/ }

Question 3

आदर्श रूप में, मैं इसके बजाय एक निर्माण का उपयोग करूंगा:

for (std::vector<your_type>::const_iterator i = things.begin(); i != things.end(); ++i)
{
  // if you ever need the distance, you may call std::distance
  // it won't cause any overhead because the compiler will likely optimize the call
  size_t distance = std::distance(things.begin(), i);
}

इसका एक बड़ा फायदा है कि आपका कोड अचानक कंटेनर अज्ञेय बन जाता है।

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

int int_distance = static_cast<int>(distance);

जो संकलक को आपके इरादे को स्पष्ट रूप से निर्दिष्ट करेगा: यह आपको चेतावनी के साथ बग नहीं देगा।

Question 4

आप / iterators का उपयोग करते हैं कर सकते हैं नहीं होगा नहीं और अगर आप / नहीं का उपयोग नहीं होगा सकते हैं std::size_tपाश सूचकांक के लिए, एक बनाने .size()के लिए intहै कि दस्तावेजों धारणा और रूपांतरण स्पष्ट रूप से संकलक चेतावनी मौन करने करता रूपांतरण समारोह।

#include <cassert>
#include <cstddef>
#include <limits>

// When using int loop indexes, use size_as_int(container) instead of
// container.size() in order to document the inherent assumption that the size
// of the container can be represented by an int.
template <typename ContainerType>
/* constexpr */ int size_as_int(const ContainerType &c) {
    const auto size = c.size();  // if no auto, use `typename ContainerType::size_type`
    assert(size <= static_cast<std::size_t>(std::numeric_limits<int>::max()));
    return static_cast<int>(size);
}

फिर आप अपने छोरों को इस तरह लिखते हैं:

for (int i = 0; i < size_as_int(things); ++i) { ... }

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

यदि आप रिलीज़ संस्करण में भी मानने में विफलताओं को पकड़ना चाहते हैं, तो आप दावे को एक बयान से बदल सकते हैं जो कुछ ऐसा फेंकता है std::out_of_range("container size exceeds range of int")।

ध्यान दें कि यह हस्ताक्षरित / अहस्ताक्षरित तुलना के साथ-साथ संभावित sizeof(int)! = sizeof(Container::size_type)समस्या दोनों को हल करता है। आप अपनी सभी चेतावनियों को सक्षम छोड़ सकते हैं और अपने कोड के अन्य भागों में वास्तविक बग्स को पकड़ने के लिए उनका उपयोग कर सकते हैं।

Question 5

आप उपयोग कर सकते हैं:

size_t प्रकार, चेतावनी संदेश निकालने के लिए
पुनरावृत्तियाँ + दूरी (जैसे पहले संकेत हैं)
केवल पुनरावृत्तियों
कार्य वस्तु

उदाहरण के लिए:

// simple class who output his value
class ConsoleOutput
{
public:
  ConsoleOutput(int value):m_value(value) { }
  int Value() const { return m_value; }
private:
  int m_value;
};

// functional object
class Predicat
{
public:
  void operator()(ConsoleOutput const& item)
  {
    std::cout << item.Value() << std::endl;
  }
};

void main()
{
  // fill list
  std::vector<ConsoleOutput> list;
  list.push_back(ConsoleOutput(1));
  list.push_back(ConsoleOutput(8));

  // 1) using size_t
  for (size_t i = 0; i < list.size(); ++i)
  {
    std::cout << list.at(i).Value() << std::endl;
  }

  // 2) iterators + distance, for std::distance only non const iterators
  std::vector<ConsoleOutput>::iterator itDistance = list.begin(), endDistance = list.end();
  for ( ; itDistance != endDistance; ++itDistance)
  {
    // int or size_t
    int const position = static_cast<int>(std::distance(list.begin(), itDistance));
    std::cout << list.at(position).Value() << std::endl;
  }

  // 3) iterators
  std::vector<ConsoleOutput>::const_iterator it = list.begin(), end = list.end();
  for ( ; it != end; ++it)
  {
    std::cout << (*it).Value() << std::endl;
  }
  // 4) functional objects
  std::for_each(list.begin(), list.end(), Predicat());
}

Question 6

मैं C ++ 11 के लिए निम्नलिखित समाधान भी प्रस्तावित कर सकता हूं।

for (auto p = 0U; p < sys.size(); p++) {

}

(C ++ ऑटो p = 0 के लिए पर्याप्त स्मार्ट नहीं है, इसलिए मुझे p = 0U .... लगाना होगा)

Question 7

मैं आपको एक बेहतर विचार दूंगा

for(decltype(things.size()) i = 0; i < things.size(); i++){
                   //...
}

decltype है

एक घोषित इकाई या अभिव्यक्ति के प्रकार और मूल्य श्रेणी का निरीक्षण करता है।

तो, यह प्रकार घटाता है things.size()और iएक प्रकार के रूप में ही होगा things.size()। तो, i < things.size()बिना किसी चेतावनी के निष्पादित किया जाएगा

Question 8

मुझे भी ऐसी ही समस्या का समाधान करना पड़ा था। Size_t का उपयोग करना काम नहीं कर रहा था। मैंने दूसरी कोशिश की जो मेरे लिए काम करती है। (नीचे के अनुसार)

for(int i = things.size()-1;i>=0;i--)
{
 //...
}

Question 9

मैं बस करूँगा

int pnSize = primeNumber.size();
for (int i = 0; i < pnSize; i++)
    cout << primeNumber[i] << ' ';