В чем преимущество такого своеобразного форматирования?

Проще добавить параметр в конце, начиная с дублирования предыдущего параметра (строки).

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

Единственное преимущество, которое я бы увидел, это когда вы добавляете параметр, вам просто нужно скопировать и вставить последнюю строку, сэкономив вам пару дополнительных нажатий клавиш для редактирования позиции запятой и т. д.

Злоба?

А если серьезно, то иногда бывает сложно учесть стиль форматирования. Во многом это вопрос личного вкуса. Лично я считаю, что формы и то и другое немного неприятны, если вы серьезно не ограничены с точки зрения длины строки.

Я знаю, когда я оборачиваю и в sql или в операторе if, я пытаюсь убедиться, что и является началом следующей строки.

Если A и B
и C

Я думаю, это проясняет, что C по-прежнему является частью if. Первый формат, который вы покажете, может быть таким. Но, как и в случае с большинством вопросов о стиле, все просто: если команда выбирает один стиль, то его следует придерживаться.

Мне кажется, это личный выбор.

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

std::cout << "some info "
    << "some more info " << 4
    + 5 << std::endl;

(Обратите внимание, в этом случае разбивать 4 + 5 глупо, но если у вас сложная математическая инструкция, это может быть необходимо).

Я часто использую это, особенно когда имею дело с условными выражениями, такими как операторы if, for и while. Потому что в однострочных условных выражениях также часто опускаются фигурные скобки.

 std::vector<int> v = ...;
 std::vector<int> w = ...;
 for (std::vector<int>::iterator i = v.begin()
       , std::vector<int>::iterator j = w.begin()
       ; i != v.end() && j != w.end()
       ; ++i, ++j)
           std::cout << *i + *j << std::endl;

Это довольно распространенный стиль кодирования при написании операторов SQL:

SELECT field1
     , field2
     , field3
--   , field4
     , field5
FROM tablename

Преимущества:

• Позволяет легко добавлять, удалять или изменять порядок полей, не беспокоясь о последней конечной запятой.
• Позволяет легко закомментировать строку (TSQL использует "-"), не нарушая остальную часть оператора.

Я бы не подумал, что вы захотите менять порядок параметров в функции так же часто, как в SQL, так что, возможно, это просто чья-то привычка.

Возможность прокомментировать один из них будет зависеть от конкретного используемого языка. Не уверен в C++. Я знаю, что VB.Net этого не допустит, но это потому, что для разделения операторов по строкам требуется символ продолжения (_).

Нет причин, я подозреваю, это просто вопрос личных предпочтений.

Лично я предпочитаю второй.

void function (int a,
               int b,
               int c
              )

Еще одно преимущество состоит в том, что в первом примере вы можете закомментировать строки B или C, и это останется синтаксически правильным. Во втором примере, если вы попытаетесь закомментировать строку C, у вас будет синтаксическая ошибка.

На самом деле не стоит делать это так уродливо, если вы спросите меня.

The only benefit I would see, is when you add a parameter, you just have to copy and paste the last line, saving you the extra couple key strokes of editing comma position and such.

То же самое происходит, если вы удаляете последний параметр.

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

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

function(
          int a,
          int b,
//          int c,
          int d
        )

Вы можете сказать, что не можете сделать это с последним параметром, и будете правы, но с другой формой вы не можете сделать это с первым параметром:

function (
//             int a
           , int b
           , int c
           , int d
          )

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