Если мы говорим о поделках на коленке, то стандарты второстепенны.
Если мы говорим о промышленном программировании, то стандарты ключ к успеху.
Вы бы согласились ездить на автомобиле в котором не соблюдаются стандарты,
пить лекарства в которых дозировки не стандартизированы?
Если i - простой тип данных и для него не перегружена операция сложения, то все просто.
Если же i это объект сложного типа и оператор + переопределен то не все так очевидно.
Топикстартер не указал где используется форматирование указанного кода, если в лабораторой работе в универе - то условия очевидны, важно сдать лабораторку. При промышленном программировании требования к коду совсем другие. Например, может быть несколько веток и несколько релизов, перенос изменений из одной в другую ветку могут быть регламентированы. мифическая красота кода отодвигается на другое место, далеко не первое.

Проблема в том, что ты не являешься Лицом Принимающим Решение. А ЛПР видит все с другой высоты, и когда ты съешь достаточно говна, то будешь смотреть на свою проблему под другим углом ;)

объяснение безусловно хорошее

Только тогда мне начинает казаться, что если строка типа i=i+1 требует объяснения ввиду её неочевидности(?) сложности(?) то это скорее говорит о больших недостатках в другом месте.

Но это философское замечание, наверняка есть ситуации, где такое действительно оправдано.

сиди гадай, что из этого реальная правка, а что просто для красоты

diff -w / git diff -w

В ядро не примут.

И я не удивлён. Мне первый вариант мешает, нужно делать усилие для того что бы его понять, но человек существо способное приспособится. Когда люди хотят подобных странных вещей говоря что им так удобнее то я обычно смотрю, а как у них устроена работа и почему у них возникают трудности касательно этого и как правило оказывается что и инструменты и методы работы и навигации по коду они не используют нормально и архитектура кода у них «лапша в столбик толстыми файлами» и они пытаются ещё уплотнить их :) Но думаю у вас не так всё плохо и вы всего лишь оптимизируете там где оптимизировать не нужно.

public void foo   (Double a)            {fn(0, 0, a,  "foo");   }
public void foo   (Double a, Integer b) {fn(0, b, a,  "foo");   }
public void bar   (Double a)            {fn(a, 0, 0d, "bar");   }
public void bar   (Double a, Integer b) {fn(a, b, 0d, "bar");   }
public void foobar(Double a, Integer b) {fn(a, b, a,  "foobar");}

Говно.

public void foo(Double a) 
{
    fn(0, 0, a, "foo");  
}
public void foo(Double a, Integer b) 
{
    fn(0, b, a,  "foo");
}
public void bar(Double a) 
{
    fn(a, 0, 0d, "bar");
}
public void bar(Double a, Integer b) 
{
    fn(a, b, 0d, "bar");   
}
public void foobar(Double a, Integer b) 
{
    fn(a, b, a,  "foobar");
}

Ещё большее говно.

Я даже не могу представить - насколько надо упороться, чтобы родить такую:

public void bar   (Double a)            {fn(a, 0, 0d, "bar");   }

В чём проблема написать как человек?

public void foobar(double a, integer b) {fn(a, b, a, "foobar");}
public void bar(double a) {fn(a, 0, 0d, "bar");}//так


public void foobar(double a, integer b) { fn(a, b, a, "foobar"); }
public void bar(double a) { fn(a, 0, 0d, "bar"); }//либо так

Как там у тебя, с кукушкой всё нормально? или логику не завезли? будь последователен, ты же гений

А я так старался:

Как  там             у   тебя,
с    кукушкой        всё нормально?
или  логику          не  завезли?
будь последователен, ты  же         гений

Допускаете ли вы такой стиль кода?

public void foobar(Double a, Integer b) {fn(a, b, a, «foobar»);}

Если код JS после работы минизмизатора, то регулярно допускаю, даже все в одну строку.

Так я последователен. Изначально там Царский вариант и был.

проблема написать

проблемы написать нету, есть проблема прочитать, так вот первый вариант тса читается лучше твоего высера

Трепло, убого, почему ты не пишешь так:

Как  там             у   тебя,
с    кукушкой        всё нормально?
или  логику          не  завезли?
будь последователен, ты  же         гений

Бегом побежал писать, либо опять обосрался?

почему ты не пишешь так:

Пишу. Но не всегда.

Где, покажи. Я пощёлкал твои комменты/темы - не увидел, чтобы ты писал так. Как и не увидел, чтобы ты писал так тут.

Бегом побежал писать

Ладно, ладно

Отчёт по работе

Багов исправлено:    15
Багов добавлено:      8
Костылей вставлено:  10
Фич запилено:         3

Я пощёлкал твои комменты/темы - не увидел, чтобы ты писал так.

Я же не говорю, о том, чтобы так писать всегда и везде.

А у многих так:

Отчёт по работе

Багов исправлено: 15 Багов добавлено: 8 Костылей вставлено: 10 Фич запилено: 3

Я тут попробовал на пайтоне на полшишечки. А то значит используешь какую-то там тяжелую PyCharm...

Поставил значит SublimeText с пакетом Anaconda.

Вообще писать невозможно. Это непередаваемое ощущение, когда кто-то тебя постоянно бьёт по рукам.

Вроде как с другими языками такой экспиеренс не получишь. Или есть подобное?

Ты просто решил эмулировать таблицу, а не текст. Ты давай, не съезжай с темы. К тому же, даже тут ты сел в лужу - у тебя тут правое, а не левое выравнивание.

Как не говоришь - ты говоришь, что в коде так писать нужно - пиши везде. Ты либо пишешь, либо не пишешь. Притягивать за уши какие-то колхозные примеры - это гулпо.

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

Именно. Как и в случае с кодом.

К тому же, даже тут ты сел в лужу - у тебя тут правое, а не левое выравнивание.

Могу поставить левое, какая разница?

Как не говоришь - ты говоришь, что в коде так писать нужно - пиши везде.

Ну так я пишу «табличкой», когда эта самая «табличка» нужна. Вот в первом варианте табличка - норм, я считаю. Но это только моё мнение, вот я и запостил посмотреть, что люди скажут и чем они это аргументируют.

Именно. Как и в случае с кодом.

Неверно, у таблицы константная структура - у кода нет. К тому же, почему ты игнорируешь мои тезисы? Где форматирование в таблицу текста? Почему ты начал мазаться и съехал с темы?

Могу поставить левое, какая разница?

Большая - это говорит о том, что ты даже не пытался быть последовательным, а придумывал убогие оправдания.

К тому же, ты тут обосрался не только с выравниванием, но и с:

Отчёт по работе

//обсёр номер раз нету выравнивания слов.
Багов    исправлено:    15
Багов    добавлено:      8
Костылей вставлено:  10
Фич      запилено:         3
//обсёр номер два - какого хрена ты на выравнил: по примеру с ():

Багов исправлено  :    15
Багов добавлено   :      8
Костылей вставлено:  10
Фич запилено      :         3


//обсёр номер три - заранее табличная структура.

Багов исправлено:  15
Багов добавлено:   8
Костылей вставлено:10
Фич запилено:      3

//но я тебя пощажу - пусть будет так:


Багов исправлено:   15
Багов добавлено:    8
Костылей вставлено: 10
Фич запилено:       3

//и того, твоя параша должна выглядеть так:


Багов    исправлено: 15
Багов    добавлено : 8
Костылей вставлено : 10
Фич      запилено  : 3

Ну так я пишу «табличкой», когда эта самая «табличка» нужна.

Она ненужна. Нет ни единого основания для этих убогих потуг, т.к. строка кода существует отдельно. Ты хочешь через таблицу выделить их схожесть? Для чего?

Выравнивание - это чисто стиль описания структуры - он унифицирован для всего. Не существует таких маня манёвров вида «я захотел - обосрался и начал вещать „ну иногда нужно“» - не нужно.

Тут уже говорили по поводу blame в vcs, когда можно быстро найти кто правил строчку и в рамках какого бага, а тут табличка будет будет машинизироваться и дельта изменений будет огромной, придется искать причины перебором log(n) т.е. бинарным поиском, самолично просматривая измениния. Приходилось так искать, когда кто-то фиксил минорые ворнинги над wtf кодом, без blame тяжело.

Я тебе даже объясню, берём твой код:

//таблица
            |имя  |параметры            |тело
public void foo   (Double a)            {fn(0, 0, a,  "foo");   }
public void foo   (Double a, Integer b) {fn(0, b, a,  "foo");   }
public void bar   (Double a)            {fn(a, 0, 0d, "bar");   }
public void bar   (Double a, Integer b) {fn(a, b, 0d, "bar");   }
public void foobar(Double a, Integer b) {fn(a, b, a,  "foobar");}

Всё это ненужно:
            |имя  |параметры            |тело
public void foo    Double a              fn(0, 0, a,  "foo");   
public void foo    Double a, Integer b   fn(0, b, a,  "foo");   
public void bar    Double a              fn(a, 0, 0d, "bar");   
public void bar    Double a, Integer b   fn(a, b, 0d, "bar");   
public void foobar Double a, Integer b   fn(a, b, a,  "foobar");



//во-первых, это везде и всюду нелепая херня. Все эти вещи уже синтаксически выделены - () - параметры, {} - тело. Нет никакого смысла их разделять.

Таблица существует для того, чтобы описывать стрктуру.
|a   |b
|asd | asd
|dsa | dsa

Она отделяет одну часть данных от другой, она их структурирует. 

Тут ты уже идиот, когда поставил: что уже структурирует. Именно поэтому твоеточие в таблице никто не ставит.


Это примерно как писать так.
Как идиот.
Зачем мне думать?
Зачем понимать?

В данном примере я выделяю предложение "новой строкой", но его уже выделяет заглавная буква и точка. Зачем я делаю одно и тоже 10раз?

Если ты можешь думать и дружишь с логикой - ты не будешь в одно и тоже место сувать 10 вещей делающих одно и тоже. 

Багов    исправлено: 15
Багов    добавлено : 8
Костылей вставлено : 10
Фич      запилено  : 3

Ну это - красиво, мне тут и сказать нечего.

Она ненужна. Нет ни единого основания для этих убогих потуг, т.к. строка кода существует отдельно. Ты хочешь через таблицу выделить их схожесть? Для чего?

Они все делают почти одно и тоже, вот я и хочу их всех выстроить так, чтобы видно было только различия.

Придерживаюсь следующего стиля написания кода.

// -------------------------------------
// --- Тип ресурса
//
//     Используется для формирования данных об стандартных ресурсах /массив StdTypeResource/
//
typedef struct  TypeResource__  {

 INT    TypeResource;                                      // Тип ресурса
 TCHAR  *NameType;                                         // Наименование типа ресурса
 TCHAR  *NameExtType;                                      // Тип файла в котором сохраняется исходные данные ресурса
 TCHAR  *NameExtDecompile;                                 // Тип файла в котором сохраняется результат декомпиляцми ресурса

} TypeResource_;

// ---------------------------------------------------------------------------
// --- Принимает из Flex данные об распознанных лексемах и сохраняет их /в векторах .../
//
INT  SaveFlexAnalysStruct(
 char  *yytext,
 INT   TypeLex
) {
/*

 yytext                 Текст содержащий распознанную лексему

 TypeLex                Тип лексемы:

                        == 1  -  Идентификатор;
                        == 2  -  Ссылка /идентификатор/;

 Return:                Код возврата:

                         ==  1  -  Ok;
                         ==  0  -  При анализе обнаружены ошибки;
                         == -1  -  Неправильно задана спецификация идентификатора;
                         == -2  -  Не нашли наименование типа поля структуры
                         == -3  -  Был встречен символ "]", но ранее не был встречен символ "["

*/

 INT        iVp01        = NULL;                           // 

 INT        iCodeRet     = NULL;                           // 
      
 HRESULT     hr;
 
 CHAR        *pLexem     = nullptr;                        // Ппринятая от flex лексема

 TCHAR       *pchLexem   = nullptr;                        // Адрес сконвертированной лексемы

 INT         TypeField   = NULL;                           // For loop

 MetaField_  *pMetaField = &pFlexState->MetaField;         // Для более простой записи доступа к полям

 INT         cntyytext   = strlen( (LPCSTR) yytext );      // Количество символов в yytext

 pLexem = yytext;                                          //

// -------------------------------------
// --- Приняли идентификатор или название структуры
//
 if  ( TypeLex == Flex_ID_ ) {

  pFlexState->flExpress = 0;                               // Еще не встретили ";"

  if  ( pFlexState->FlStruct == 0 ) {                      // "}" /окончание блока/

   pFlexState->pMetaFixedStruct->pNameStruct =             // Создаем копию строки pLexem, содержащюю название структуры
    (CHAR *)  hb_strdup(        
     yytext
    );

   pFlexState->pLinksMetaObjects->vMetaFixedStruct.push_back(  // Добавляем в LinksMetaObjects_ ссылку на структуру, содержащюю данные об метаданных структуры
    pFlexState->pMetaFixedStruct
   );

   *(CHAR *)( pFlexState->pNameStruct) = '\0';

   return  1;                                              // Ok

  }                                                        // if  ( TypeLex == Flex_EndBlock_ ) { 

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

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

Они все делают почти одно и тоже, вот я и хочу их всех выстроить так, чтобы видно было только различия.

Ты опять обосрался.

//Есть ты определяешь несовпадения по вертикали за различия, то
//у тебя не должно быть различий в труктуре.

//Сейчас у тебя всё выглядит так, будто бы в первой функции есть ),
//а во второй вместо неё запятая.

public void foo   (Double a)            {fn(0, 0, a,  "foo");   }
public void foo   (Double a, Integer b) {fn(0, b, a,  "foo");   }
public void bar   (Double a)            {fn(a, 0, 0d, "bar");   }
public void bar   (Double a, Integer b) {fn(a, b, 0d, "bar");   }
public void foobar(Double a, Integer b) {fn(a, b, a,  "foobar");}

//правильно так
public void foo   (Double a           ) {fn(0, 0, a , "foo"   );}
public void foo   (Double a, Integer b) {fn(0, b, a , "foo"   );}
public void bar   (Double a           ) {fn(a, 0, 0d, "bar"   );}
public void bar   (Double a, Integer b) {fn(a, b, 0d, "bar"   );}
public void foobar(Double a, Integer b) {fn(a, b, a , "foobar");}

//хотя это тоже неверно(строки не форматированы, но форматирование строк сломает твоё дерьмо. Но это близко к тому, что ты описываешь.

В первом случае сразу видны отличия, а во втором — нужно читать и разбираться. Это важное достоинство. Но если это сломает мозг другим читателям — оно того не стоит.

Это - Царь. Он говорит, как Царь. Ему можно.

Меня мало волнует потуги рандомного трепло что-то там мне кукаректаь. Не громлю - иди показывай, разоблачай меня, клоун. Что же ты мямлишь херню и боишься кукарекнуть хоть что-то конкретное? Почему все твои нелепые потуги - это шаблонная дошколятская херня? Тебе вчера сосед по парте эту херню сообщил и ты решил повторить мне, думая, что она чего-то стоит?

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

Ну строки - это костыль. А такое форматирование я где-то видел, но не скажу где.

Тебе нужен свой форум, блог или еще что-нибудь. Пользовался бы успехом.

Вот, вся суть и потолок дошколятского трепла. «ааа, видно лучше - я так сказал. А там нужно, а тут ненужно - я так сказал». Т.е. трепло попросту неспособно обосновать свои нелепые потуги. Почему видно, что видно, почему в другом невидно. Зачем, оно же у мамки гений - мамка всегда сынке говорила, что всё что он вскукарекнет - правда правдивая.

Опять со стилями своими... Почему люди перестали головой думать. Есть только !ОДНО! правило, которое должно быть соблюдено, вне зависимости от того на каком языке ты пишешь, и это правило - ЧИТАЕМОСТЬ. Все остальное это следствия. Но макаки не понимают, что с какой стороны и пехают дальше темки про кодстайл. Познай, где причина, а где следствие, познай дзен.

Дело не в форматировании. Это очевидное решение, которое бы ты выбрал, если бы причина твоего форматирования была реальной той, что ты назвал.

А пока что я вижу так «мне просто удобнее/нравиться как в табличке - я пишу так», «ой, мне спросили - почему. Ну давай я придумаю что-то». От того такие расхождения и появляются.

На самом деле какая-то часть объективности в этом есть - сравнение по вертикали действительно имеет смысл и проще, но - ты в любом случае не сможешь это так просто сравнивнить - ты должен будешь парсить код в голове(т.к. у тебя есть расхождения в структуре, которых быть не должно).

И тут действительно можно поверить, что тебе будет проще, но - это костыль убогий. Ты же читаешь код - ты уже автоматом должен парсить сигнатуры. Я считаю это решение говном, а твои доводе не особо состоятельными, но допустим.

Если ты хочешь сказать, что эти функции идентичны и это просто врапперы - засунь это в макросы. Будет и таким как ты и таким как я.

Анон, ты не конструктивен. Учись у Царя.

Если ты хочешь сказать, что эти функции идентичны и это просто врапперы - засунь это в макросы.

Не могу. В яве нет макросов.

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

Ну так что, табличкой писать перегрузки норм или не норм?

На самом деле это решение будет лучшим. Во-первых мы уберём триггер у многих пациентов на однострочники. Во-вторых уберём невероятно разрастание кода вызванное стилем говна.

Три строчки ещё можно потратить место одной. Хотя на самом деле мы тратим всего одну строчку. Это приемлемый компромисс.

Но вот стиль дерьма - никогда не понимал и не пойму. Уж лучше твоя таблица чем это.

Пырь код suckless тулз. Там читаемый код. Дальше начинай думать. И думай. Думай своей головой, а не ищи решение несуществующих проблем. ДУМАЙ. ПРОСТО ДУМАЙ.

Разве это жизнь?

Джуну по рукам не дать за кодстайл, помнить лишнее, жать много клавиш, субъективные споры красиво ли тут.

Если ток в нии штанишки протирать или в попенсурс ради фана.

Но стандарты не обазательно соблюдать всю жизнь

Пф... «соблюдать». Норм. посоны давно стандарты себе создают, «беря все лудшЭе от N конкурирующих» ну хотя бы не пуская явную ересь в апстрим на основе консенсуса по проектным коде-стайлам :)

Ты опять обосрался.

запахло царём, все в посад!

Это ничего. Всё образуется.

Мне кажется предпочтительнее второй вариант, сам бы сделал именно так