int i, x;
for (i = istart, x = xstart; condition(i, x); i+=istep, x+=xstep)

template<typename T>
class CommaSetter
{
public:
 CommaSetter(_variant_t& v) : m_v ( v ) {}
 template<typename V> void operator , (const V& v)
 {
  m_v = v;
 }
private:
 _variant_t& m_v;
};

template<>
class CommaSetter<void>
{
public:
 CommaSetter(_variant_t&) {}
};


template <typename C, typename R>
class CInvokeHandler0
{
 typedef R(C::*FUNC)();
public:
 CInvokeHandler0(FUNC func) : m_func(func) {}
 void Invoke(C* pObj, _variant_t& rRes, DISPPARAMS* pDispParams)
 {
  if (pDispParams->cArgs != 0)
  {
   _com_issue_error(DISP_E_BADPARAMCOUNT);
  }
  CommaSetter<R>(rRes), (pObj->*m_func)();
 }
private:
 FUNC m_func;
};

bla_bla1(some_args)
[
    item1(another_args),
    item2(another_args_again),
    
    bla_bla2(args)
    [
        item3(...),
        item4(...),
        ...
    ],
    item5(...),
    ...
];

struct X {
  bool _ = (f(), false);
};

struct X {
  static bool _;
};
bool X::_ = (f(), false);

(void)std::initializer_list<int>{(f(t), 0)...};

HRESULT f(BOOL* b) { return *b = FALSE, E_NOTIMPL; }

decltype(f(), g(), 0)

for(... it = arr.begin(), itEnd = arr.end(); it != itEnd; ++it) { ... }

void
SomeMethod(t_Item const & item1, t_Item const & item2)
{
    t_Item item3;
    ::std::vector< t_Item > items;
    (t_BackInserter(items)), item1, item2, t_Item(), item2, item3, Make_Item();
}

t_Command start("start");
t_Command wait("wait", 2);
t_Command finish("finish")
(t_CommandExecuter()), start, t_Command("do something"), wait, t_Command("do something else"), wait, finish;

return (scoped_lock(lock)), value;

foo[ _1, _2 ]

lxa>> template<typename V> void operator , (const V& v) // А какой смысл именно в запятой здесь? operator << было бы логичней, нет?
lxa>>

rRes = (pObj->*m_func)();