Односвязный список и оператор индексирования []

class TMyObject()
{
 
};
 
class TMyObjectList()
{
public:
  TMyObject* operator[](int Index) const;
};

TMyObject* TMyObjectList::operator[](int Index) const
{
  ...
  return pMyObject;
}

TMyObjectList* MyList = new TMyObjectlist();
...
for (int i= 0; i<MyList.Count; i++)
  MyList[i]

 MyList[i] ->....

class TMyObject()
{
public:
  int GetWidth();
  __declspec(property(get=GetWidth))int Width;
};

class TMyObjectList()
{
public:
  TMyObject* operator[](int Index) const;
};

  TMyObject* pTemp;
  pTemp = MyList->operator[](i);
  int n = pTemp->Width;

operator[](int i)
      { return f[i];}

   cout << ff[i] << endl;

return pMyObject[index];

pTemp = Mylist->operator[](i)

 int n = MyList[i]->Width;

template<typename T>
class single_list {
    
    struct node {
        T data;
        node * next;
    };
    
public:
    T & operator [](std::size_t index) {
        node * p = head;
        while (index--) {
            p = p->next;
        }
        return p->data;
    }    
    
private:
    node * head;
};

[S]TMyObject*[/S] operator[](int Index)
{
return [S]Mylist[/S][Index];
}

// ListTest.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
#include <iostream>
 
class TPanel
{
public:
    TPanel(int width){m_Width = width;};
    ~TPanel();
    int m_Width;
    int GetWidth(){return m_Width;};
    void SetWidth(int newWidth){m_Width = newWidth;};
    __declspec(property(get=GetWidth, put=SetWidth)) int Width;
};
 
class TPanelNode
{
public:
    TPanelNode(){pNext = nullptr;};
    ~TPanelNode();
    TPanelNode* pNext;  
    TPanel* Panel;
    TPanel& GetPanel(){return *Panel;};
};
 
class TPanelsList
{
public:
    TPanelsList(){pHead = nullptr; m_Count = 0;};
    ~TPanelsList();
    void AddPanel(int width);
    const TPanel& operator[](int Index) const;
    int GetCount(){return m_Count;};
    __declspec(property(get=GetCount)) int Count;
private:
    TPanelNode* pHead;
    int m_Count;
};
 
void TPanelsList::AddPanel(int width)
{
    if (!pHead)
    {
        pHead = new TPanelNode();
        pHead->Panel = new TPanel(width);
    }
    else
    {
        TPanelNode* pTemp = pHead;
        while (pTemp->pNext)
            pTemp = pTemp->pNext;
        pTemp->pNext = new TPanelNode;
        pTemp = pTemp->pNext;
        pTemp->Panel = new TPanel(width);       
    }
    ++m_Count;
}
 
const TPanel& TPanelsList::operator[](int Index) const
{
    int indx = Index;
    TPanelNode* pTemp = pHead;
    while (indx > 0)
    {
        if (pTemp->pNext)
            pTemp = pTemp->pNext;
        else
            break;
        --indx;
    }
    return pTemp->GetPanel();
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    TPanelsList* PanelsList = new TPanelsList();
    std::cout << PanelsList->Count << "\n";
    PanelsList->AddPanel(20);
    std::cout << PanelsList->Count << "\n"; 
    PanelsList->AddPanel(30);
    std::cout << PanelsList->Count << "\n";
    std::cout << "Panel1 width: " << PanelsList[0]->Width << "\n";
    
 
    std::cin.get();
    return 0;
}

PanelsList[0]->Width

(*PanelList)[0].Width

 (*PanelList)