код infix_iterator

Ничего важного (только некоторые личные мнения):

Согласованный интервал

    infix_ostream_iterator(ostream_type& s)
        : os(&s),delimiter(0), first_elem(true)
    {}  //    ^^^ No Space   ^^^Trailing space

Согласование типа Именование

// Here we have & on the left
infix_ostream_iterator<T,charT,traits>& operator=(T const &item)

// Here we have it on the right
infix_ostream_iterator<T,charT,traits> &operator*() {

Написание кода delimter

Я очень сильно ошибаюсь при написании этого => delimiter

Легче читать список инициализаций

Так же, как я предпочитаю один оператор в строке, я предпочитаю одну переменную, инициализированную на строку в списке инициализаторов (легче читать).

infix_ostream_iterator(ostream_type& s, charT const *d)
    : os(&s)
    , delimiter(d)
    , first_elem(true)
{}

Удалите if из основного корпуса.

Вероятно, это не имеет никакого значения для производительности, но я бы удалил if, чтобы код выглядел следующим образом:

*os << delimter << item;
delimter = actualDelimter;
return *this;

При построении actualDelimter точки в строке, предоставленной пользователем (или пустой строкой) и delimter, указывают на пустую строку.

Единственное, что я могу критиковать в коде, это несогласованное размещение пробелов между операторами-инфиксами и объявлениями указателей /ссылок.

class charT=char,
public std::iterator<std::output_iterator_tag,void,void,void,void>

â € | и т. д., пробелы.

: os(&s),delimiter(0), first_elem(true)

â € | и т. д., непоследовательное использование пробелов.

infix_ostream_iterator<T,charT,traits>& operator=(T const &item)
infix_ostream_iterator<T,charT,traits> &operator*() {

â € | и т. д., Несогласованное размещение &.

Iâ € ™ d также унифицирует использование пустых строк между определениями функций и удаляет пустую строку между блоком template <…> и заголовком класса, а также конец определения класса.

Ничтожное, конечно, но это буквально единственное, что критиковать.

Я также объявляю первый конструктор как явный:

explicit infix_ostream_iterator(ostream_type &s)
        : os(&s)
    {}

Хотя я могу себе представить, что использование такого итератора весьма ограничено, таким образом вы не гарантируете, что не будет никакого нежелательного преобразования типов.

Хранить указатели const char

Я согласен с предложенными Lokis изменениями, за исключением того, что я оставил delimiter и real_delim как charT const * и изменил конструктор на:

infix_ostream_iterator(ostream_type &s, charT const *d = 0)
 : os(&s)
 , delimiter("")
 , real_delim(d ? d : "")
{
}

Таким образом мы уменьшаем стоимость копирования строк, вместо этого мы просто копируем указатель.

Выведенные типы

Подражая изменениям, внесенным в std :: less в C + +14, вы можете сделать шаблон operator=, поэтому нам не нужно указывать этот тип для класса. Это приведет к потере совместимости с интерфейсом std::ostream_iterator.

template <class T>
infix_ostream_iterator<charT, traits> &operator=(T const &item)
{
    *os << delimiter << item;
    delimiter = real_delim;
    return *this;
}

Прежде всего, хорошая идея с этим классом! Я согласен с изменениями, уже предложенными другими пользователями (Loki, Konrad, user15108, dalle).

Кроме того, я заметил, что infix_ostream_iterator не является конструктивным по умолчанию. Это подходит для использования и следует за дизайном std::ostream_iterator. Поэтому вы можете сохранить std::basic_ostream в качестве переменной-члена ссылки. То есть

class infix_ostream_iterator : ... {
    ...
    std::basic_ostream<charT,traits>& os;
    ...
}

Теперь вы можете удалить указатель, который упростит оставшийся код. Например, конструктор становится

infix_ostream_iterator(ostream_type &s, charT const *d)
    : os(s)
    , real_delim(d)
{}

и вы можете напрямую писать в поток

os << delimiter << item;

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

Ожидаем увидеть этот класс в чем-то вроде Boost! Удачи вам в подаче.

Я знаю, что я много лет опаздываю на это, но я хочу выкинуть идею: почему дела с разделителями и без разделителей должны быть одного типа? Ваша первоначальная версия использовала charT const*, а ваша новая версия использует std::basic_string<charT> ... но кажется расточительным иметь две строки string s, которые мы копируем, чтобы обрабатывать не имеющие разделителя.

Я предлагаю иметь перегруженную функцию make_*, которая либо создает ваш итератор, либо создает стандартный:

// no delimiter
template <class T, class CharT, class Traits>
std::ostream_iterator<T, CharT, Traits>
make_delim_iterator(std::basic_ostream<CharT,Traits>& );

// yes, delimiter
template <class T, class CharT, class Traits>
infix_ostream_iterator<T, CharT, Traits>
make_delim_iterator(std::basic_ostream<CharT,Traits>&, CharT const*);

Это позволит вам иметь два члена CharT const* вместо двух basic_string<CharT>, и ваш тип всегда использует разделитель.