Kullanılan kapsayıcıyı açığa çıkarmadan yineleyicileri nasıl gösterebilirim?

Question

C# 'yi bir süredir kullanıyorum ve C++' ya geri dönmek baş ağrıyor. C# 'den bazı uygulamalarımı C++' ya taşımaya çalışıyorum ama biraz direnç buluyorum ve yardımınızı kabul etmekten memnuniyet duyarım.

Böyle bir sınıf için bir yineleyici maruz istiyorum:

template <class T> 
class MyContainer 
{ 
public: 
    // Here is the problem: 
    // typedef for MyIterator without exposing std::vector publicly? 

    MyIterator Begin() { return mHiddenContainerImpl.begin(); } 
    MyIterator End() { return mHiddenContainerImpl.end(); } 

private: 
    std::vector<T> mHiddenContainerImpl; 
}; 

Ben bir sorun değildir şeye çalışıyor muyum? Sadece std yazmalıyım :: vector < T> :: yineleyici? Ben

Answer 1

Sen may Şu makaleyi yazdığınız sorunun tam olarak ele alındığı şu makaleyi bulabilirsiniz: On the Tension Between Object-Oriented and Generic Programming in C++ and What Type Erasure Can Do About It

Answer 2

İstediğin yapmalıyım ... sadece yineleyici değil, uygulayıcı konteyner bağlı üzerine umuyorum:

typedef typename std::vector<T>::iterator MyIterator; 

Accelerated C++ Gönderen:

Bir tipin yaşadığımızda

, vector<T> gibi, bir şablon parametresine bağlıdır ve bu türden bir üyeyi kullanmak istediğiniz, örneğin, bir tür olan size_type gibi, uygulamanın adını ad olarak kabul etmesini sağlamak için tüm adı önce typename olmalıdır. bir tür.

Answer 3

sana "alenen std :: vector maruz bırakmakla" ile ne demek emin değilim ama aslında, sadece o sevdiği typedef tanımlayabilirsiniz:

typedef typename std::vector<T>::iterator iterator; 
typedef typename std::vector<T>::const_iterator const_iterator; // To work with constant references 

Bu typedefs değiştirmek mümkün olacak

typedef typename std::vector<T>::size_type size_type; 
typedef typename std::vector<T>::difference_type difference_type; 
typedef typename std::vector<T>::pointer pointer; 
typedef typename std::vector<T>::reference reference; 

: daha sonra arada kullanıcı bir şey fark ...

olmadan, size sınıf kapsayıcı olarak davranmasını istiyorsanız Ayrıca birkaç diğer türleri ortaya çıkarmak için uygulama iyi sayılır

Ve sınıfı tarafından gerekirse: STL documentation on vectors

Düzenleme::

Burada var typedef tüm bu anlamını bulacaksınız Yorum önerilen olarak typename eklendi

Answer 4

Aşağıdakileri daha önce yaptım hat kapsayıcıdan bağımsız bir yineleyici aldım. Bu, arayanın tüm elemanlarla doldurulması gereken bir vector<T*>& numaralı telefondan geçtiği ve daha sonra arayanın doğrudan vektörden yineleyebileceği bir API kullanabildiğim için bu fazla olabilirdi.

template <class T> 
class IterImpl 
{ 
public: 
    virtual T* next() = 0; 
}; 

template <class T> 
class Iter 
{ 
public: 
    Iter(IterImpl<T>* pImpl):mpImpl(pImpl) {}; 
    Iter(Iter<T>& rIter):mpImpl(pImpl) 
    { 
     rIter.mpImpl = 0; // take ownership 
    } 
    ~Iter() { 
     delete mpImpl; // does nothing if it is 0 
    } 
    T* next() { 
    return mpImpl->next(); 
    } 
private: 
    IterImpl<T>* mpImpl; 
}; 

template <class C, class T> 
class IterImplStl : public IterImpl<T> 
{ 
public: 
    IterImplStl(C& rC) 
    :mrC(rC), 
    curr(rC.begin()) 
    {} 
    virtual T* next() 
    { 
    if (curr == mrC.end()) return 0; 
    typename T* pResult = &*curr; 
    ++curr; 
    return pResult; 
    } 
private: 
    C& mrC; 
    typename C::iterator curr; 
}; 


class Widget; 

// in the base clase we do not need to include widget 
class TestBase 
{ 
public: 
    virtual Iter<Widget> getIter() = 0; 
}; 


#include <vector> 

class Widget 
{ 
public: 
    int px; 
    int py; 
}; 

class Test : public TestBase 
{ 
public: 
    typedef std::vector<Widget> WidgetVec; 

    virtual Iter<Widget> getIter() { 
     return Iter<Widget>(new IterImplStl<WidgetVec, Widget>(mVec)); 
     } 

    void add(int px, int py) 
    { 
     mVec.push_back(Widget()); 
     mVec.back().px = px; 
     mVec.back().py = py; 
    } 
private: 
    WidgetVec mVec; 
}; 


void testFn() 
{ 
    Test t; 
    t.add(3, 4); 
    t.add(2, 5); 

    TestBase* tB = &t; 
    Iter<Widget> iter = tB->getIter(); 
    Widget* pW; 
    while (pW = iter.next()) 
    { 
     std::cout << "px: " << pW->px << " py: " << pW->py << std::endl; 
    } 
}