processWidget(std::shared_ptr<T>(new T), f());

SL>·>processWidget(std::shared_ptr<T>(new T), f());
SL>·>

template<typename T, typename... Ts>
std::unique_ptr<T> make_unique(Ts&&... params)
{
  return std::unique_ptr<T>(new T(std::forward<Ts>(params)...));
}

Evaluation of an expression might produce side effects. At certain specified points in the execution se-
quence called sequence points, all side effects of previous evaluations shall be complete and no side effects of subsequent evaluations shall have taken place.

C>Evaluation of an expression might produce side effects. At certain specified points in the execution se-
C>quence called sequence points, all side effects of previous evaluations shall be complete and no side effects of subsequent evaluations shall have taken place.
C>

processWidget(std::shared_ptr<Widget>(new Widget), computePriority()); // potential resource leak!
...
Compilers are not required to generate code that executes them in this order. “new Widget” must be executed before the std::shared_ptr constructor may be called, because the result of that new is used as an argument to that constructor, but compute Priority may be executed before those calls, after them, or, crucially, between them. That is, compilers may emit code to execute the operations in this order:
1. Perform “new Widget”.
2. Execute computePriority.
3. Run std::shared_ptr constructor.
If such code is generated and, at runtime, computePriority produces an exception, the dynamically allocated Widget from Step 1 will be leaked, because it will never be stored in the std::shared_ptr that’s supposed to start managing it in Step 3.

1. (tmp_t = new T(); std::shared_ptr::constructor(tmp_t);)
2. (b());

static int global = 0;

void bar() {
   std::cout << global;
}

void increment() {
   global++;
}

foo(global(), bar());

C>1. (tmp_t = new T(); std::shared_ptr::constructor(tmp_t);)
C>2. (b());
C>

Где находятся точки следования

1 В конце каждого полного выражения(Глава Стандарта 1.9/16). Обычно они помечены точкой с запятой ;

2 В точке вызова функции (1.9/17). Но после вычисления всех аргументов. Это и для inline функций в том числе.

3 При возвращении из функции. (1.9/17) Есть точка следования сразу после возврата функции, перед тем как любой другой код из вызвавшей функции начал выполняться.

4 (1.9/18) После первого выражения (здесь оно называется 'a') в следующих конструкциях:

a || b

a && b

a , b

a ? b : c

Вычисление здесь идет слева направо. То есть левое выражение (по имени 'a') вычисляется и все побочные эффекты от такого вычисления завершаются. Потом, если все значение всего выражения известно, правое выражение не вычисляется, иначе вычисляется.
Правило слево-направо не работает для переопределенных операторов. В этом случае переопределенный оператор ведет себя как обычная функция. Еще такой момент — ?: не может быть переопределен по стандарту.
(Упомянутая запятая это оператор запятая. Она не имеет никакого отношения к запятой, разделяющей аргументы функции.)

When calling a function (whether or not the function is inline), there is a sequence point after the evaluation
of all function arguments (if any) which takes place before execution of any expressions or statements in
the function body.