1

我想对要从文本中跳过某些字符的文本进行正则表达式搜索。这里提出的原始问题：维护状态的正则表达式库，逐个字符地输入并在找到匹配时返回真 为此，我制作了一个自定义迭代器，并试图将这些迭代器传递给 regex_iterator。但我收到以下错误：


regex(2775): error C2512: 'fixed_array::iterator' : no appropriate default constructor available
          with
          [
              T=char
          ]
regex(2773) : while compiling class template member function 'std::tr1::regex_iterator::regex_iterator(void)'
          with
          [
              _BidIt=fixed_array::iterator
          ]
iterator.cpp(168) : see reference to class template instantiation 'std::tr1::regex_iterator' being compiled
          with
          [
              _BidIt=fixed_array::iterator
          ]
regex(2775): error C2512: 'fixed_array::iterator' : no appropriate default constructor available
          with
          [
              T=char
          ]

这是我的代码：



    template 
    class fixed_array
    {
        public:

        typedef int size_type;

        class iterator
        {
            public:
            typedef iterator self_type;
            typedef T value_type;
            typedef T& reference;
            typedef T* pointer;
            typedef std::bidirectional_iterator_tag iterator_category;
            typedef int difference_type;
            iterator(pointer ptr) : ptr_(ptr) { }

            self_type operator++() /*skip character 'a'*/
            {
                self_type i = *this;
                ptr_++;
                if(*ptr_ == 'a')
                ptr_++;
                return i;
            }

            self_type operator++(int junk)
            {
                ptr_++;
                if(*ptr_ == 'a')
                ptr_++;
                return *this;
            }

            reference operator*()
            {
                return *ptr_;
            }

            pointer operator->()
            {
                return ptr_;
            }

            bool operator==(const self_type& rhs)
            {
                return ptr_ == rhs.ptr_;
            }

            bool operator!=(const self_type& rhs)
            {
                return ptr_ != rhs.ptr_;
            }
            private:
            pointer ptr_;
        };

        class const_iterator
        {
            public:
            typedef const_iterator self_type;
            typedef T value_type;
            typedef T& reference;
            typedef T* pointer;
            typedef int difference_type;
            typedef std::bidirectional_iterator_tag iterator_category;
            const_iterator(pointer ptr) : ptr_(ptr) { }
            self_type operator++() { self_type i = *this; ptr_++; return i; }
            self_type operator++(int junk) { ptr_++; return *this; }
            const reference operator*() { return *ptr_; }
            const pointer operator->() { return ptr_; }
            bool operator==(const self_type& rhs) { return ptr_ == rhs.ptr_; }
            bool operator!=(const self_type& rhs) { return ptr_ != rhs.ptr_; }
            private:
            pointer ptr_;
        };


        fixed_array(size_type size) : size_(size) {
            data_ = new T[size_];
        }

        size_type size() const { return size_; }

        T& operator[](size_type index)
        {
            assert(index < size_);
            return data_[index];
        }

        const T& operator[](size_type index) const
        {
            assert(index < size_);
            return data_[index];
        }

        iterator begin()
        {
            return iterator(data_);
        }

        iterator end()
        {
            return iterator(data_ + size_);
        }

        const_iterator begin() const
        {
            return const_iterator(data_);
        }

        const_iterator end() const
        {
            return const_iterator(data_ + size_);
        }

        private:
        T* data_;
        size_type size_;
    };

    using namespace std;

    int main()
    {
        fixed_array<char> point3d(50);

        //initialize the array with some string.
        regex e ("a.*ea");

        fixed_array<char>::iterator beg = point3d.begin();
        fixed_array<char>::iterator end = point3d.end();

        regex_iterator<fixed_array<char>::iterator> rit ( beg, end, e );
        regex_iterator<fixed_array<char>::iterator> rend;

        while (rit!=rend) {
            cout << rit->str() << std::endl;
            ++rit;
        }
        return 0;
    }
4

2 回答 2

2

过滤器迭代器很难正确处理。此外，您的 const 和非常量迭代器是不一致的。

我建议您使用Boost filter_iterator而不是自己编写东西。

于 2013-06-12T15:43:04.307 回答
0

好的，最终在塞巴斯蒂安的回答和一些研究的帮助下，我能够实现我想要做的事情。

我使用了以下页面中给出的过滤器迭代器代码：http: //blogs.msdn.com/b/vcblog/archive/2010/08/09/the-filterator.aspx

除了上面的迭代器之外，这是我写的：

struct is_current_charT {
    bool operator()(char s) const {
        return s != 't';
    }
};

int main() {
    using namespace std;

    string str = "test1 ,,ktest2,, ktest3,, ktest0,,";
    regex e ("kes[0-9]");

    auto fit = make_filterator(str.begin(), str.end(),
        is_current_charT());

    filterator<string::iterator,is_current_charT> cdogs(fit);

    regex_iterator<filterator<string::iterator,is_current_charT>> rit ( cdogs, cdogs.end(), e );
    regex_iterator<filterator<string::iterator,is_current_charT>> rend;

    while (rit!=rend) {
        cout << rit->str() << std::endl;
        ++rit;
    }
}

输出：

kes2
kes3
kes0

现在可以轻松修改它以编写更有意义的过滤函数。

感谢艾哈迈德，感谢塞巴斯蒂安！

于 2013-06-13T11:26:41.623 回答