Live example with custom iterators

在这样做的时候,我发现我只能将原始指针传递给STL算法,它们似乎工作正常.以下是没有任何迭代器的示例：

#include <cstddef>
#include <iostream>
#include <iterator>
#include <algorithm>
 
template<typename T>
class my_array{
    T* data_;
    std::size_t size_;
 
public:
 
    my_array()
        : data_(NULL),size_(0)
    {}
    my_array(std::size_t size)
        : data_(new T[size]),size_(size)
    {}
    my_array(const my_array<T>& other){
        size_ = other.size_;
        data_ = new T[size_];
        for (std::size_t i = 0; i<size_; i++)
            data_[i] = other.data_[i];
    }
    my_array(const T* first,const T* last){
        size_ = last - first;
        data_ = new T[size_];
 
        for (std::size_t i = 0; i<size_; i++)
            data_[i] = first[i];
    }
 
    ~my_array(){
        delete [] data_;
    }
    const my_array<T>& operator=(const my_array<T>& other){
        size_ = other.size_;
        data_ = new T[size_];
        for (std::size_t i = 0; i<size_; i++)
            data_[i] = other.data_[i];
        return other;
    }
    const T& operator[](std::size_t idx) const {return data_[idx];}
    T& operator[](std::size_t& idx) {return data_[idx];}
    std::size_t size(){return size_;}
 
    T* begin(){return data_;}
    T* end(){return data_+size_;}
};
 
template<typename T>
void print(T t) {
    std::cout << t << std::endl;
}
 
int main(){
 
 
    typedef float scalar_t;
    scalar_t list [] = {1,3,5,2,4,10,10};
    my_array<scalar_t> a(list,list+sizeof(list)/sizeof(scalar_t));
 
    // works!
    for (scalar_t* it = a.begin(),*end = a.end();
         it != end; ++it)
        std::cout << ' ' << *it;
    std::cout << std::endl;
 
    // works!
    std::for_each(a.begin(),a.end(),print<scalar_t>);
    std::cout << std::endl;
 
    // works!
    my_array<int> b(a.size());
    std::copy(a.begin(),b.begin());
 
    // works!
    scalar_t* end = std::remove(a.begin(),5);
    std::for_each(a.begin(),end,print<scalar_t>);
    std::cout << std::endl;
 
    // works!
    std::random_shuffle(a.begin(),end);
    std::for_each(a.begin(),print<scalar_t>);
    std::cout << std::endl;
 
    // works!
    std::cout << "Counts of 3 in array = " << std::count(a.begin(),3) << std::endl << std::endl;
 
    // works!
    std::sort(a.begin(),print<scalar_t>);
    std::cout << std::endl;
 
    // works!
    if (!std::binary_search(a.begin(),5))
        std::cout << "Removed!" << std::endl;
 
    return 0;
}

Live example without iterators

我的问题如下：

>这是否适用于具有线性存储容器？我知道这对于链表不起作用.
>如果他们在这种情况下工作,为什么我还要经历执行迭代器的麻烦呢？我知道迭代器如何泛化我的代码,但是,如果这个简单的数组是我需要的,那么我看不到这一点.
>如果这种做法总是有效,我正在做什么的负面问题？一方面,我可以看到我正在打破数据封装.