覆蓋自定義數據結構的迭代器的僅運算符*（）

Question

我有一個數組類MyArray和MyArray 。
為了簡單起見，這就是整個代碼。 可以。

當前代碼

#include <iostream>
using namespace std;
template<class T> class MyArray;
template<class T>class MyIterator{
    public: int index=0;
    public: MyArray<T>* myArray;
    public: MyIterator<T> operator++(){
        index++;
        return *this;
    }
    public: T& operator*(){
        return myArray->database[index];
    }
    public: friend bool operator!=(MyIterator<T> b,MyIterator<T> c){
        return b.index!=c.index;
    }
};
template<class T>class MyArray{
    public: T database[5];
    public: MyArray(){
        database[2]=3; //just fill with something to test
    }
    public: MyIterator<T> begin(){
        MyIterator<T> r;  r.index=0; r.myArray=this;
        return r;
    }
    public: MyIterator<T> end(){
        MyIterator<T> r;  r.index=5; r.myArray=this;
        return r;
    }
};

這是它的用法：

int main() {
    MyArray<int> test;
    for(int ele:test){
        std::cout<<ele<<std::endl;
    }
    return 0;
}

問題/要求

我有特定的類，可以說它們的名稱是B和C
我有一個從B到C 的轉換器 ，名為convertBToC(B) 。

現在，我想要一個新的數據結構（名為MyArray2 ）：-

• 表現得像MyArray<B> ...。
• 除了MyArray2的迭代器的函數operator*() 返回C而不是B
• 返回的C ，使用convertBToC(B)從B進行轉換。

這是我希望用於（ #1 ）的用法：

MyArray2 test;
//test.push_back(B());  //used like "MyArray<B>"
for(C c:test){          //"C", not "B"
    .... logic about "c" ....  
}  

上面的代碼就像我這樣稱呼它：-

MyArray<B> arr;   
for(B& b: arr){
    C c= convertBToC(b);   //<-- I want to hide this line
    .... logic about "c" .... 
}

問題：如何編寫MyArray2 ？

標准

我想要一個解決方案：-（按優先級排序）

• 高效（不使用std::function及其家族）
• 不要直接引用MyIterator （因為MyIterator是一個內部類）
• 可愛（語句/行少，可讀）
• 對MyArray<T>最小更改（如果有）

最相關的問題在這里 ，但它提到了std::vector 。

我可憐的解決方案

解決方案1（2x繼承）

創建2個課程：-

• 從MyArray<B>派生的MyArray2
  覆蓋： begin()或end() -返回MyIterator2 。

• MyIterator2衍生自MyIterator<B>
  覆蓋： operator*() -返回C （使用convertBToC() ）。

壞處：

• 臟-我必須創建2個類才能僅覆蓋1個函數。
• MyArray2.h代碼包含單詞MyIterator<T> 。

解決方案2（lambda）

僅創建1個課程：-

• 從MyArray<B>派生的MyArray2
  新功能： iterate() ：-

這是iterate()的草案：

template<typename F> MyArray2::iterate( F lamdbaFunction ){
    for(B b: MyArray<B>){
         C c= convertBToC(b);
         lamdbaFunction(c);
    }
}

用法必須從#1更改為...（ #2 ）

MyArray2 arr;   
auto lambdaF=[&](C c){     
    .... logic about "c" .... 
}
arr.iterateElement(lambdaF);

壞處

• 有時會破壞可讀性。 （Lambda有時更難閱讀）
• 它限制了編碼風格。 （有時，我更喜歡基於范圍的循環。）

Answer 1

另一種方法是使用Boost范圍適配器，特別是boost::adaptors::transformed 。

#include <boost/range/adaptor/transformed.hpp>
...

MyArray<B> test;
for(C ele : test | boost::adaptor::transformed(convertBToC)) {
    // something...
}

判斷自己的進步有多大。 也許最好把operator| 在新的MyArray的成員函數中調用。