for( autp a : cont)
{
    doWith(a);
}

for( bla::bla<bla>::const_iterator bit = cont.begin(); bit != cont.end(); ++bit)
{
    if (bit == cont.begin())
        std::cout<<", ";
}

#include <iostream>
#include <boost/range/iterator_range.hpp>

int main()
{
    const int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // Just process the first element separately. No checks required in the loop.
    std::cout << *std::begin(array);
        
    for (const auto& item : boost::make_iterator_range(array, 1, 0))
    {
        std::cout << ", " << item;
    }
}

M>for( autp a : cont)
M>{
M>    doWith(a);
M>}
M>

for (auto& a : cont)
{
  auto first = &a == &cont.front();
  auto last = &a == &cont.back();
}

const char* comma = "";
for( auto a : cont)
{
  std::cout<< comma << a;
  comma = ", ";
}

#include <iostream>
#include <boost/range/iterator_range.hpp>

template <typename SequenceT>
void print_sequence(const SequenceT& seq)
{
    if (!std::empty(seq))
    {
        std::cout << "[" << std::front(seq);
        
        for (const auto& item : boost::make_iterator_range(seq, 1, 0))
        {
            std::cout << ", " << item;
        }
        std::cout << "]"<< std::endl;
    }
}

int main()
{
    const int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    print_sequence(array);
}

#include <iostream>
#include <vector>
#include <boost/range/adaptor/indirected.hpp>

int main()
{
   std::cout << std::boolalpha;

   int t = 42;
   std::vector<const int*> v(10, &t);

   const auto cont = v | boost::adaptors::indirected;
    
   for (auto& a : cont)
   {
      auto first = &a == &cont.front();
      auto last = &a == &cont.back();

      std::cout << first << ", " << last << std::endl;
   }

}

R>Однако. Вырезал слова "и дело тут совсем не в быстродействии" и начал отстаивать свою позицию именно с точки зрения быстродействия

#include <iostream>
#include <boost/range/iterator_range.hpp>

template <typename SequenceT>
void print_sequence(const SequenceT& seq)
{
    if (!boost::empty(seq))
    {
        std::cout << "[" << *std::begin(seq);
        
        for (const auto& item : boost::make_iterator_range(seq, 1, 0))
        {
            std::cout << ", " << item;
        }
        std::cout << "]"<< std::endl;
    }
}

int main()
{
    const int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    print_sequence(array);
}

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> vec(10, 5);
    for( const auto &v : vec )
    {
        if (&v!=!vec.front()) std::cout<<", ";
        std::cout<<v;
    }
}

#include <iostream>
#include <boost/range/iterator_range.hpp>

template <typename SequenceT>
void print_sequence(const SequenceT& seq)
{
    if (!boost::empty(seq))
    {
        auto it = std::begin(seq);
        std::cout << "[" << *it;
        ++it;
        
        for (; it!=std::end(seq); ++it)
        {
            std::cout << ", " << *it;
        }
        std::cout << "]"<< std::endl;
    }
}

int main()
{
    const int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    print_sequence(array);
}

M>Да если столько писанины в итоге, то уже как-то и не важно, в каком виде этот несчастный for будет

    std::cout << *std::begin(array);
        
    for (const auto& item : boost::make_iterator_range(array, 1, 0))
    {
        std::cout << ", " << item;
    }

   for (auto& a : cont)
   {
      auto first = &a == &cont.front();
  
      if (!first)
      {
          std::cout << ", ";
      }

      std::cout << item;
   }

M>Ну, после того как ты его максимально удлиннил, то конечно этот вариант стал похуже

    std::cout << cont.front();

    for (auto& a : boost::make_iterator_range(cont, 1, 0))
        std::cout << ", " << a;

   for (auto& a : cont)
   {
      if (&a != &cont.front())
          std::cout << ", ";

      std::cout << item;
   }

    if (!cont.empty())
    {
        std::cout << cont.front();

        for (auto& a : boost::make_iterator_range(cont, 1, 0))
            std::cout << ", " << a;
    }

   for (auto& a : cont)
   {
      if (&a != &cont.front())
          std::cout << ", ";

      std::cout << item;
   }

M>for( autp a : cont)
M>{
M>    doWith(a);
M>}
M>

  std::function<void(int)> f = [&] (int n) { 
                                             f = [](int n){ std::cout << ", " << n; };
                                             std::cout << n;
                                           };
  for(auto item : v)
    f(item);

  if ( auto it = std::begin(v), itEnd = std::end(v); itEnd != it )
  {
    std::cout << *it;
    for(++it; itEnd != it; ++it)
    {
      std::cout << ", " << *it;
    }
  }

#include <algorithm>
#include <experimental/iterator>
#include <iostream>
#include <iterator>
 
int main()
{
    int i[] = {1, 2, 3, 4, 5};
    std::copy(std::begin(i),
              std::end(i),
              std::experimental::make_ostream_joiner(std::cout, ", "));
}

Output:

1, 2, 3, 4, 5

BFE>  if ( auto it = std::begin(v), itEnd = std::end(v); itEnd != it )
BFE>  {
BFE>    std::cout << *it;
BFE>    for(++it; itEnd != it; ++it)
BFE>    {
BFE>      std::cout << ", " << *it;
BFE>    }
BFE>  }
BFE>

  if (!std::empty(v))
  {
    std::cout << std::front(v);
    for(auto it = std::begin(v) + 1; it != std::end(v); ++it)
    {
      std::cout << ", " << *it;
    }
  }

if ( auto [it, itEnd] = {std::begin(v), std::end(v)}; itEnd != it )

BFE>if ( auto [it, itEnd] = {std::begin(v), std::end(v)}; itEnd != it )
BFE>

{

    auto && __range = range_expression ;
    for (auto __begin = begin_expr, __end = end_expr; __begin != __end; ++__begin) {

        range_declaration = *__begin;
        loop_statement

    }

}

{

    auto && __range = range_expression ;
    auto __begin = begin_expr ;
    auto __end = end_expr ;
    for ( ; __begin != __end; ++__begin) {

        range_declaration = *__begin;
        loop_statement

    }

}

BFE>>if ( auto [it, itEnd] = {std::begin(v), std::end(v)}; itEnd != it )
BFE>>

  int i1 = 1;
  int i2 = 2;
  auto [a, b] = {i1, i2};

#include <iterator>
#include <string>
#include <iostream>
 
template <typename T>
struct reversion_wrapper { T& iterable; };
 
template <typename T>
auto begin (reversion_wrapper<T> w) { return std::rbegin(w.iterable); }
 
template <typename T>
auto end (reversion_wrapper<T> w) { return std::rend(w.iterable); }
 
template <typename T>
reversion_wrapper<T> reverse (T&& iterable) { return { iterable }; }
 
int main (int, char**)
{
    std::string foo("Hello World!");
    for (const auto& it: reverse(foo))
        std::cout << it;

    // Для выводна в обратном порядке, наверное, проще будет std::reverse_copy
    std::reverse_copy(foo.begin(), foo.end(), std::ostream_iterator<int>(std::cout));
    return 0;
}

struct A
{
    int n;
    char* s;
};
A a = {1, nullptr};

auto [a, b]{i1, i2};

BFE>struct A
BFE>{
BFE>    int n;
BFE>    char* s;
BFE>};
BFE>A a = {1, nullptr};
BFE>

BFE>

BFE>auto [a, b]{i1, i2};
BFE>

int i;
char c;

auto list = { i, c }; // initalizer_list, fail

auto [a, b] = list; // fail даже если list состояится как initializer_list, потому что он не массив и не тупл, значит привязка пойдет по членам класса.

BFE>initalizer_list отсутствует в structured binding описании.

Otherwise e is defined as if by using its name instead of [ identifier-list ] in the declaration.

auto [a, b] = {1,2,3};
// =>
auto e = {1,2,3}; // initializer_list
...

_NN>Насколько я понимаю в теории можно специализировать std::get для initalizer_list и тогда код соберётся

 const auto [x, y] = std::forward_as_tuple(a, b);

using fat = ::std::forward_as_tuple;

R>Потому, что "с = с + 1" — это ++С

Connoisseurs of C semantics find C++ inferior to ++C.

using fat = ::std::forward_as_tuple;

_NN>Можно попытаться через stdcpp.ru

float operator =>(MyVariant from, float to)
{
  if ( ! from.IsFloat() )
    throw std::bad_cast();
        
  to = from.get<float>();

  return to;
}

int operator =>(float from, int to)
{
  if ( static_cast<float>(static_cast<int>(from)) != from )
    throw std::bad_cast();
        
  to = static_cast<int>(from);

  return to;
}

MyVariant my(1.2f);
float my => f;
int f => n;

float x = 1.f;
o => x;

std::size_t const size = std::size( data );
for( auto [ i, v ] = enumerate( data ) ) {
    if( i == 0 ) {} // первый элемент (или единственный, если size( data ) == 1)
    else if( i + 1 == size ) {} // последний элемент
    else {} // между первым и последним
}

for( auto [ i, v ] : enumerate( data ) ) {
    if( i != 0 ) {
        std::cout << ", ";
    }
    std::cout << v;
}