Недавно столкнулся с такой проблемой:

Мне нужно распарсить некоторый текст, формат которого предполагает наличие комментариев.
Комментарий начинается с определённого символа и заканчивается другим.
Всё что находится внутри закомментированого блока должно быть проигнорированно.
Комментарий может начинаться где угодно (не обязательно в начале строки)

Для парсинга использую boost::regex + boost::tokenizer..

Вопрос: Как наиболее логичнее организовать поддержку комментариев?
Метод "влоб" - это просто удалить из строки все комменты, и уже дальше парсить её.. Но этот вариант не очень(

Сейчас сделал так:
Написал свой bidirectional итератор, который при инкрементировании/декриментировании если встречает начало коммента, просто перескакивает его..
Подсовываю этот итератор в boost::regex и boost::tokenizer вместо std::string::const_iterator.. И всё работает)
Без существенного переписывания кода.. (спасибо гибкости boost)

Вот маленький пример: символ начала коммента - %, конец коммента - \n):

C++ (Qt)
#include <iostream>
#include <boost/regex.hpp>
#include <string>
#include <list>
#include <boost/range/istream_range.hpp>
#include <algorithm>
 
template <class T = char>
class tex_string_iterator : public std::iterator<std::bidirectional_iterator_tag, T, ptrdiff_t, const T*, const T&>
{
public:
    typedef T char_type;
    typedef std::basic_string<T> string_type;
    typedef typename std::basic_string<T>::const_iterator string_iterator;
 
    tex_string_iterator(string_iterator begin, string_iterator end, T bra = '%', T ket = '\n')
        : _begin(begin), _end(end), _it(begin), _bra(bra), _ket(ket)
    {
        make_comments_list();
    }
 
    tex_string_iterator(const tex_string_iterator<T>& iter)
        : _begin(iter._begin), _end(iter._end), _it(iter._it),
          _bra(iter._bra), _ket(iter._ket), _comments_list(iter._comments_list) {}
 
    tex_string_iterator<T>& operator=(const tex_string_iterator & iter) {
        if (this != &iter) {
            _begin = iter._begin;
            _end = iter._end;
            _it = iter._it;
            _bra = iter._bra;
            _ket = iter._ket;
            _comments_list = iter._comments_list;
        }
        return *this;
    }
 
    tex_string_iterator() {}
 
    ~tex_string_iterator() {}
 
    const T& operator*() const { return *_it; }
 
    const T* operator->() const { return _it; }
 
    tex_string_iterator<T>& operator++() {
 
        if (*_it != _bra) {
            if (++_it == _end)
                return *this;
            if (*_it != _bra)
                return *this;
        }
 
        for (const auto & comment : _comments_list) {
            if (comment.begin() == _it) {
                _it = comment.end();
                if (_it == _end)
                    break;
 
                if (*(++_it) != _bra)
                    break;
            }
        }
 
        return *this;
    }
 
    tex_string_iterator<T> operator++(int) {
        tex_string_iterator<T> tmp = *this;
        ++*this;
        return tmp;
    }
 
    tex_string_iterator<T>& operator--() {
 
        if (*_it != _ket) {
            --_it;
            if (*_it != _ket)
                return *this;
        }
 
        for (const auto & comment :_comments_list) {
            if (comment.end() == _it) {
                _it = comment.begin();
                if (_it == _begin)
                    break;
 
                if (*(--_it) != _ket)
                    break;
            }
        }
 
        return *this;
    }
 
    tex_string_iterator<T> operator--(int) {
        tex_string_iterator<T> tmp = *this;
        --*this;
        return tmp;
    }
 
    template <class R>
    friend bool operator==(const tex_string_iterator<R> &, const tex_string_iterator<R> &);
 
    template <class R>
    friend bool operator!=(const tex_string_iterator<R> &, const tex_string_iterator<R> &);
 
private:
    string_iterator _begin;
    string_iterator _end;
    string_iterator _it;    //current iterator
    T _bra;                 //open comment symbol
    T _ket;                 //closed comment symbol
    std::list<boost::iterator_range<string_iterator>> _comments_list;
 
    void make_comments_list() {
        if (_begin == _end)
            return;
 
        auto first = _begin;
        auto second = _begin;
 
        while ((first = std::find(first, _end, _bra)) != _end) {
            second =  std::find(first, _end, _ket);
            _comments_list.push_back(boost::iterator_range<string_iterator>(first, second));
            first = second;
        }
    }
};
 
template<class T>
inline bool operator==(const tex_string_iterator<T> & x, const tex_string_iterator<T> & y) {
    return (x._it == y._it);
}
 
template<class T>
inline bool operator!=(const tex_string_iterator<T> & x, const tex_string_iterator<T> & y) {
    return !(x == y);
}
 
int main()
{
 
    std::string buffer = "text text %comment comment\n text nocomment";
 
    tex_string_iterator<char> ibegin(buffer.begin(), buffer.end(), '%', '\n');
    tex_string_iterator<char> iend(buffer.end(), buffer.end());
 
    boost::regex_iterator<tex_string_iterator<char>> it(ibegin, iend, boost::regex("(com)"));
    boost::regex_iterator<tex_string_iterator<char>> end;
    for (; it != end; ++it) {
        std::cout << it->str(1) << std::endl;
    }
 
   return 0;
}
 

Сейчас меня такой вариант устраивает..
Но хотелось бы и другие соображения/подходы пообсуждать.
  

Ну вобщем то сейчас парсер и делает свою работу.. В том смысле, что сами регулярки не изменились: как если бы комментов и вовсе не было.. (т.е. за комменты отвечает не сам парсер, а итератор: фактически обёртка над string::const_iterator)

Почему не хочу делать влоб - хочется избежать затратного переаллоцирования памяти при удалении комментов.. (особенно если входной файл большой)

А вообще, в таких ситуациях обычно как поступают? (ситуация то вполне рядовая..?) Просто интересно.. 

По-моему, так и поступают, сначала подготавливают текст, потом подают на вход специализированного процессора. Затраты на распределение памяти сейчас минимальные. Для себя я давно решил- лучше сделать проще и понятнее, чем эффективнее и сложнее. Ну, разве что, если задача критична к затратам, или хочется сделать красиво из любви к искусству...

Значит, из текста выделить комментарии и подать на вход другого процессора. Который может только комментарии обрабатывать. Вы поняли, куда я клонил?

Таки про него я и намекаю. Смотрите сразу новую версию, думаю вам понравиться.

Одной строкой описания правила.

Обязательно.
В этих примерах комментарий начинается от // и #, а заканчивается eol (концом строки).

Что значит не принципиально?
Комментарии всегда начинаются с определённой последовательности и заканчиваются определённой последовательностью. Обязательно.