चार्ट में एक कुंजी के रूप में * का उपयोग करना :: मानचित्र

Question 1

मैं यह पता लगाने की कोशिश कर रहा हूं कि निम्न कोड क्यों काम नहीं कर रहा है, और मुझे लगता है कि यह चार प्रकार के कुंजी के रूप में * का उपयोग करने के साथ एक मुद्दा है, हालांकि मुझे यकीन नहीं है कि मैं इसे कैसे हल कर सकता हूं या यह क्यों हो रहा है। मेरे द्वारा उपयोग किए जाने वाले अन्य कार्यों (HL2 SDK में) का char*उपयोग std::stringकरने से सभी अनावश्यक जटिलताओं का कारण बनने जा रहा है।

std::map<char*, int> g_PlayerNames;

int PlayerManager::CreateFakePlayer()
{
    FakePlayer *player = new FakePlayer();
    int index = g_FakePlayers.AddToTail(player);

    bool foundName = false;

    // Iterate through Player Names and find an Unused one
    for(std::map<char*,int>::iterator it = g_PlayerNames.begin(); it != g_PlayerNames.end(); ++it)
    {
        if(it->second == NAME_AVAILABLE)
        {
            // We found an Available Name. Mark as Unavailable and move it to the end of the list
            foundName = true;
            g_FakePlayers.Element(index)->name = it->first;

            g_PlayerNames.insert(std::pair<char*, int>(it->first, NAME_UNAVAILABLE));
            g_PlayerNames.erase(it); // Remove name since we added it to the end of the list

            break;
        }
    }

    // If we can't find a usable name, just user 'player'
    if(!foundName)
    {
        g_FakePlayers.Element(index)->name = "player";
    }

    g_FakePlayers.Element(index)->connectTime = time(NULL);
    g_FakePlayers.Element(index)->score = 0;

    return index;
}

Question 2

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

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

struct cmp_str
{
   bool operator()(char const *a, char const *b) const
   {
      return std::strcmp(a, b) < 0;
   }
};

map<char *, int, cmp_str> BlahBlah;

Question 3

आप उपयोग नहीं कर सकते char*जब तक आप पूरी तरह से 100% कर रहे हैं सुनिश्चित करें कि आप के साथ नक्शा देखने के लिए जा रहे हैं ठीक उसी संकेत दिए गए , नहीं तार।

उदाहरण:

char *s1; // pointing to a string "hello" stored memory location #12
char *s2; // pointing to a string "hello" stored memory location #20

यदि आप मानचित्र को अपने साथ एक्सेस करते हैं s1तो आपको इसके साथ पहुँचने की तुलना में एक अलग स्थान मिलेगा s2।

Question 4

दो सी-स्टाइल स्ट्रिंग्स में समान सामग्री हो सकती है लेकिन अलग-अलग पते पर हो। और यह mapसंकेत की तुलना करता है, सामग्री की नहीं।

रूपांतरित करने की लागत std::map<std::string, int>उतनी नहीं हो सकती जितनी आप सोचते हैं।

लेकिन अगर आपको वास्तव const char*में मानचित्र कुंजियों के रूप में उपयोग करने की आवश्यकता है , तो कोशिश करें:

#include <functional>
#include <cstring>
struct StrCompare : public std::binary_function<const char*, const char*, bool> {
public:
    bool operator() (const char* str1, const char* str2) const
    { return std::strcmp(str1, str2) < 0; }
};

typedef std::map<const char*, int, StrCompare> NameMap;
NameMap g_PlayerNames;

Question 5

आप इसके साथ काम कर सकते हैं std::map<const char*, int>, लेकिन गैर- constपॉइंटर्स ( constकुंजी के लिए जोड़ा गया नोट) का उपयोग नहीं करना चाहिए , क्योंकि आपको उन तारों को बदलना नहीं चाहिए, जबकि नक्शा उन्हें कुंजी के रूप में संदर्भित करता है। (एक नक्शे के उन के माध्यम से अपने कुंजी की रक्षा करता है जबकि const, यह केवल constify हैं सूचक स्ट्रिंग नहीं है, यह करने के लिए इंगित करता है।)

लेकिन तुम बस का उपयोग क्यों नहीं करते std::map<std::string, int>? यह बिना सिरदर्द के बॉक्स से बाहर काम करता है।

Question 6

आप char *एक स्ट्रिंग का उपयोग करके तुलना कर रहे हैं । वे एक जैसे नहीं हैं।

A char *, char का सूचक है। अंततः, यह एक पूर्णांक प्रकार है, जिसका मान एक के लिए एक वैध पते के रूप में व्याख्या किया गया है char।

एक स्ट्रिंग एक स्ट्रिंग है।

कंटेनर सही ढंग से काम करता है, लेकिन जोड़े के लिए एक कंटेनर के रूप में जिसमें कुंजी एक है char *और मूल्य एक है int।

Question 7

जैसा कि दूसरों का कहना है, आपको इस मामले में शायद एक चार * की जगह std :: string का उपयोग करना चाहिए, हालांकि एक पॉइंटर के साथ सिद्धांत में कुछ भी गलत नहीं है यदि यह वास्तव में आवश्यक है।

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

यहां तक कि अगर आप char * को std :: string में बदलते हैं तो भी यह समस्या बनी रहेगी।

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

Question 8

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

यह पता चला है कि जैसा कि प्लाबो ने बताया है, पॉइंटर्स (प्रत्येक संकलन इकाई का अपना निरंतर चार * है) किसी अन्य सीपीपी फ़ाइल में एक्सेस होने पर बिल्कुल भी समान नहीं है।

Question 9

std::map<char*,int>कुंजी की std::less<char*,int>तुलना करने के लिए डिफ़ॉल्ट का उपयोग करेगा char*, जो एक सूचक तुलना करेगा। लेकिन आप अपनी खुद की तुलना वर्ग को इस तरह निर्दिष्ट कर सकते हैं:

class StringPtrCmp {
    public:
        StringPtrCmp() {}

    bool operator()(const char *str1, const char *str2) const   {
        if (str1 == str2)
            return false; // same pointer so "not less"
        else
            return (strcmp(str1, str2) < 0); //string compare: str1<str2 ?
    }
};

std::map<char*, YourType, StringPtrCmp> myMap;

ध्यान रखें कि आपको यह सुनिश्चित करना है कि चार * सूचक वैध हैं। मैं std::map<std::string, int>वैसे भी उपयोग करने के लिए सलाह दूंगा।

Question 10

जब तक यह तुलना ( , ) और असाइनमेंट का समर्थन करता है <, तब तक किसी भी महत्वपूर्ण प्रकार का उपयोग करने के लिए कोई समस्या नहीं है ।>==

एक बिंदु जिसका उल्लेख किया जाना चाहिए - ध्यान रखें कि आप एक टेम्पलेट वर्ग का उपयोग कर रहे हैं । परिणाम के रूप में संकलक के लिए char*और दो अलग झटपट उत्पन्न करेगा int*। जबकि दोनों का वास्तविक कोड लगभग समान होगा।

इसलिए - मैं void*एक मुख्य प्रकार के रूप में उपयोग करने पर विचार करूंगा , और फिर आवश्यक रूप से कास्टिंग करूंगा । ये मेरा विचार हे।