class IterRef
{
public:
  IterRef() : container_(NULL), index_(0){}
  IterRef(TStrings *container, size_t index) : container_(container), index_(index){}
  IterRef(const IterRef &src)
   : container_(NULL), index_(0)
  {
    *this = src;
  }
  void operator=(const IterRef &src)
  {
    *this = (TString &)src;
  }
  TString &operator()
  {
    return container_ ? container_.get(index_) : tmp_;
  }
  void operator=(const TString &val)
  {
    if(container_) container_.set(index, val);
    else tmp_ = val;
    return *this;
  }
private:
  TString tmp_;
  TStrings *container_;
  size_t index_;
};

TString str;
...
TChar* first = &str[0];
TChar* last = first + str.GetLength();
std::sort(first, last);

B>TString str;
B>...
B>TChar* first = &str[0];
B>TChar* last = first + str.GetLength();
B>std::sort(first, last);
B>

TStrings strs;
...
AnsiString *first = &(strs->Strings[0]);
*first = "Hello!";  //щассс!

TStrings strs;
...
strs->Strings[0] = "Hello!";  //пишем
cout<<strs->Strings[0]; //читаем

Items processed: 100000
Garbage size: 190

// изврат, т.е. скорее proof-of-concept. 
// посему производительность, еще оставляет желать, 
// но можно еще оптимизить неограниченно

#include <vector>
#include <string>
#include <list>
#include <map>
#include <algorithm>
#include <memory>

// Нужный класс для теста, 
// Борланда под рукой нет
template<class ValueType>
class CIndexedOwner
{
    std::vector<ValueType> m_vec;
public:
    typedef ValueType value_type;

    CIndexedOwner(ValueType size)
        : m_vec(size)
    {
    }
    ValueType Get(int iIndex)
    {
        return m_vec[iIndex];
    }
    void Set(int iIndex, ValueType value)
    {
        m_vec[iIndex] = value;
    }

    template <class ContainerType>
    void GetStatistic(ContainerType * pContainer)
    {
        for(int i=0; i<(int)m_vec.size(); ++i)
            ++ (*pContainer)[ m_vec[i] ];
    }

};

// GARBAGE
struct IDestroyable
{
    virtual ~IDestroyable(){}
};

void DeleteSubject(IDestroyable * p)
{
    delete p;
}
class CHeapGarbage
{
    typedef std::list<IDestroyable * > ListType;
    ListType m_trash;
public:
    void Add(IDestroyable * pValue)
    {
        m_trash.push_back( pValue );
    }
    ~CHeapGarbage()
    {
        std::for_each(m_trash.begin(), m_trash.end(), &DeleteSubject);
    }
    int GetSize() const
    {
        return (int)m_trash.size();
    }
};

// эту сущность отдаем по ссылке - такой себе proxy
template<class OwnerType, class ValueType>
struct PseudoWrapper:public IDestroyable
{ 
    typedef PseudoWrapper<OwnerType, ValueType> SelfType;
    OwnerType * m_pOwner;
    int m_index;

    bool m_bStandaloneMode;
    ValueType m_value;
public:
    void SetValue(const ValueType & value)
    {
        if (m_bStandaloneMode) const
            m_value = value;
        else
            m_pOwner->Set( m_index, value );
    }

    ValueType GetValue() const
    {
        if (m_bStandaloneMode)
            return m_value;
        else
            return m_pOwner->Get(m_index);
    }

    // STANDALONE MODE
    PseudoWrapper()
        : m_bStandaloneMode(true)
    {
    }

    PseudoWrapper(const SelfType & value)
        : 
           m_bStandaloneMode(true),
          m_value( value.GetValue() )
    {
    }
    
    PseudoWrapper(const ValueType & val)
        : m_bStandaloneMode(true),
          m_value(val)
    {
    }

    // PROXY MODE
    PseudoWrapper(OwnerType * pOwner, int index)
        : m_pOwner( pOwner ),
          m_index( index ),
          m_bStandaloneMode(false)
    {
    }

    // ALL MODES
    bool operator == (const SelfType & value)const
    {
        return GetValue() == value.GetValue();
    }
    bool operator < (const SelfType & value)const
    {
        return GetValue() < value.GetValue();
    }
    SelfType & operator = (const SelfType & value)
    {
        SetValue( value.GetValue() );
        return *this;
    }
    operator ValueType () const
    {
        return GetValue();
    }
    bool operator == (const ValueType & value)const
    {
        return GetValue() == value;
    }
    bool operator < (const ValueType & value)const
    {
        return GetValue() < value;
    }
    SelfType & operator = (const ValueType & value)
    {
        SetValue( value );
        return *this;
    }

};

// cache
template<class ObjectType>
class CRefCache
{
public:
    typedef std::map<void *, ObjectType *> Cache;
    typedef typename Cache::iterator iterator;

    std::pair<iterator, bool> insert(void * pAddress)
    {
        return m_cache.insert( std::pair<void *, ObjectType *>(pAddress, 0) );
    }

private:
    Cache m_cache;

};

// Наша цель:
template<class OwnerType, class ValueType, class RefCacheType>
class WeakRandomIterator
{
    typedef WeakRandomIterator<OwnerType, ValueType, RefCacheType> SelfType;
    OwnerType * m_pOwner;
    CHeapGarbage * m_pGarbage;
    int m_index;
    mutable RefCacheType * m_pCache;

public:
    typedef typename std::random_access_iterator_tag iterator_category;
    typedef ValueType value_type;
    typedef int difference_type;
    typedef difference_type distance_type;    // retained
    typedef ValueType * pointer;
    typedef ValueType & reference;

    typedef PseudoWrapper<OwnerType, ValueType> UsedWrapper;

    WeakRandomIterator()
    {
        m_pOwner = 0;
        m_pGarbage = 0;
        m_index = 0;
        m_pCache = 0;
    }

    SelfType & operator = (const SelfType & other) 
    {
        m_pOwner = other.m_pOwner;
        m_pGarbage = other.m_pGarbage;
        m_index = other.m_index;
        m_pCache =  other.m_pCache;
        return *this;
    }

    WeakRandomIterator(OwnerType * pOwner, 
                       CHeapGarbage * pGarbage,
                       int index,
                       RefCacheType * pCache)
    : 
                m_pOwner( pOwner ),
                m_pGarbage( pGarbage ),
                m_index( index ),
                m_pCache( pCache )
    {
    }

    // interesting situation below:
    UsedWrapper & operator * () 
    {
        return GetReference();
    }

    const UsedWrapper & operator * () const 
    {
        return GetReference();
    }

    UsedWrapper & GetReference()
    {
        std::pair<typename RefCacheType::iterator, bool> res = 
            m_pCache->insert( this );

        UsedWrapper * pNewObject = 0; 
        if (res.second)
        {
            // need's update
            std::auto_ptr<UsedWrapper> ptr( new UsedWrapper( m_pOwner, m_index ) );
            res.first->second = ptr.get();
            m_pGarbage->Add( ptr.get() );
            pNewObject = ptr.release();
        } 
        else
        {   // take existing
            pNewObject = &(*res.first->second);
            pNewObject->m_index = m_index;
            pNewObject->m_pOwner = m_pOwner;
        }
        return *pNewObject;
    }
    
    // операции, необходимые для std::sort
    int operator - (const SelfType & iterator) const 
    {
        return m_index - iterator.m_index;
    }

    SelfType operator - (int size) const 
    {
        return SelfType(m_pOwner, m_pGarbage, m_index - size, m_pCache);
    }

    SelfType operator + (int size) const 
    {
        return SelfType(m_pOwner, m_pGarbage, m_index + size, m_pCache);
    }
    
    bool operator < (const SelfType & obj) const 
    {
        return m_index<obj.m_index;
    }

    SelfType & operator ++ ()  
    {
        ++m_index;
        return *this;
    }

    SelfType operator ++ (int)  
    {
        SelfType obj = *this;
        ++m_index;
        return obj;
    }

    SelfType & operator -- ()  
    {
        --m_index;
        return *this;
    }

    SelfType operator -- (int) 
    {
        SelfType obj = *this;
        --m_index;
        return obj;
    }

    bool operator == (const SelfType & other) const 
    {
        return other.m_index == m_index;
    }
    
    bool operator != (const SelfType & other) const 
    {
        return other.m_index != m_index;
    }
    // foo
    ValueType Get()
    {
        return m_pOwner->Get(m_index);
    }
    void Set(const ValueType & str)
    {
        m_pOwner->Set(m_index, str);
    }

};

// for test
#include <iostream>
#include <stdlib.h>
#include <time.h>

typedef CIndexedOwner<int> CTestOwner;

int main()
{
    srand( (unsigned)time( 0 ) );

    // DATA:
    int containerSize = 10000;
    CTestOwner owner( containerSize ); 
    for(int i=0; i<containerSize; ++i)
        owner.Set(i, rand());

    // type declarations
    typedef int ValueType;
    typedef CTestOwner OwnerType;
    typedef CRefCache< PseudoWrapper<OwnerType, ValueType> > CUsedCache;
    typedef WeakRandomIterator<OwnerType, ValueType, CUsedCache> CUsedIterator;


    // пример использования
    CHeapGarbage garbage;
    CUsedCache cache;

    std::map<CTestOwner::value_type, int> statBefore, statAfter;

    owner.GetStatistic( &statBefore );
    std::sort(  CUsedIterator(&owner, &garbage, 0, &cache), 
                CUsedIterator(&owner, &garbage, containerSize, &cache));
    owner.GetStatistic( &statAfter );

    // проверим корректность
    if (statAfter != statBefore)
    {
        std::cout<<"Statistic test failed\n";
        return 1;
    }


    for(int i=1; i<containerSize ;++i)
    {
        if (owner.Get(i-1) > owner.Get(i))
        {
            std::cout<<"Test failed on position:  "<<i<<"\n";
            return 2;
        }
    }

    std::cout<<"Items processed:  "<<containerSize<<"\n";
    std::cout<<"Garbage size:  "<<garbage.GetSize()<<"\n";
    return 0;
}