मैं एक टेम्पलेटेड गतिशील सरणी में [] ऑपरेटर को अधिभारित करने का प्रयास कर रहा हूं, हालांकि ऐसा कुछ भी नहीं प्रतीत होता है?

मैंने स्कूल के लिए एक टेम्प्लेटेड डायनामिक ऐरे बनाया है, मैंने ओवरलोड को क्लास के बाहर अलग करने की कोशिश की है।

DynArray.h

template <typename T>
class DynArray
{
public:
    //The constructor initialises the size of 10 and m_Data to nullptr
    DynArray(void)
    {
        m_AllocatedSize = 10;
        m_Data = nullptr;
    }

    //deletes m_Data
    ~DynArray()
    {
        delete[] m_Data;
        m_Data = nullptr;
    }

    T* operator [] (int index)
    {
        return m_Data[index];
    }

    //creates the array and sets all values to 0
    T* CreateArray(void)
    {
        m_Data = new T[m_AllocatedSize];
        m_UsedElements = 0;

        for (int i = 0; i < m_AllocatedSize; ++i)
        {
            m_Data[i] = NULL;
        }

        return m_Data;
    }

private:

    bool Compare(T a, T b)
    {
        if (a > b)
            return true;
        return false;
    }


    T* m_Data;
    T* m_newData;
    int m_AllocatedSize;
    int m_UsedElements;
};

मुख्य.सीपीपी

#include <iostream>
#include "DynArray.h"
int main()
{
    DynArray<int>* myArray = new DynArray<int>;
    //runs the create function
    myArray->CreateArray();

    int test = myArray[2];

    delete myArray;
    return 0;
}

मुझे उम्मीद थी कि इस मामले में m_Data [2] पर ओवरलोड वापस आ जाएगा, हालांकि ऐसा लगता है कि यह [] को ओवरलोड नहीं करता है, इसके बजाय no suitable conversion from DynArray<int> to int कहता है।

c++
1
Leith Merrifield 18 जून 2019, 09:12

1 उत्तर

सबसे बढ़िया उत्तर

आप एक पॉइंटर लौटा रहे हैं जो आप नहीं चाहते हैं। आपको ऐसा करना चाहिए:

T& operator [] (const int& index)
 { 
    return   m_Data[index];
 }

साथ ही myArray एक सूचक है जिसका उपयोग करने से पहले आपको इसे हटाना होगा।

int test = (*myArray)[2];

पॉइंटर का उपयोग न करना बेहतर है:

    int main()// suggested by @user4581301
{
    DynArray<int> myArray;
    //runs the create function
    myArray.CreateArray();

    int test = myArray[2];


    return 0;
}

यहां पॉइंटर्स का उपयोग करने का कोई कारण नहीं है।

गतिशील आवंटन के लिए new और delete के बजाय smart pointers का उपयोग करना बेहतर है। यहां एक समस्या यह भी है कि आप सीमा की जांच नहीं कर रहे हैं और क्या होगा यदि सूचकांक उदाहरण के लिए एक ऋणात्मक संख्या है।

1
Oblivion 18 जून 2019, 10:01