Почему вы не объявляете несколько переменных одного типа в одной строке?

Ответ 1

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

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

Это похоже на то, что происходит, когда вы

if ((foo = some_function()) == 0) {
    //do something
}

Конечно, этот пример намного хуже вашего.

Ответ 2

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

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

Ответ 3

В С++:

int * i, j;

i имеет тип int *, j имеет тип int. Различие слишком легко пропущено.

Помимо того, что их на одной строке упрощает добавление комментариев позже

Ответ 4

В C/С++ у вас также есть проблема, что *, используемый для указания типа указателя, применяется только к непосредственно следующему идентификатору. Поэтому довольно распространенная ошибка неопытных разработчиков заключается в написании

int* var1, var2, var3;

и ожидая, что все три переменные будут иметь тип 'int pointer', тогда как для компилятора это читается как

int* var1;
int var2;
int var3;

делает только var1 указателем.

Ответ 5

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

Ответ 6

Потому что на некоторых языках var2 и var3 в вашем примере не были бы строками, они были бы вариантами (нетипизированными).

Ответ 7

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

float fMin, fMax;

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

int iBalance, iColor;

Ответ 8

Почему эта плохая практика? Я не думаю, что это так, если ваш код все еще доступен для чтения.

//not much use
int i, j, k;

//better
int counter, 
    childCounter, 
    percentComplete;

Ответ 9

Актуальность.

Просто потому, что две переменные имеют тип String, это не значит, что они тесно связаны друг с другом.

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

Ответ 10

Вот мои причины:

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

Ответ 11

Как насчет случая, например:

public static final int NORTH = 0,
                        EAST = 1,
                        SOUTH = 2,
                        WEST = 3;

Это считается плохой практикой? Я бы подумал, что все в порядке, поскольку оно учитывает некоторые из ранее сделанных пунктов:

• все они определенно будут одного типа (в моем статически типизированном Java-мире)
• комментарии могут быть добавлены для каждого
• Если вам нужно изменить тип для одного, вы, вероятно, должны сделать это для всех, и все четыре могут быть сделаны за одно изменение.

Итак, в примере (хотя и вонючий код) есть причины, по которым вы этого не сделаете?

Ответ 12

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

Ответ 13

• чтобы быть более очевидным для вас при использовании инструментов управления версиями (покрытых Michel)
• чтобы быть более читабельными для вас, когда у вас есть простейшая ошибка переполнения/недогрузки или компиляции, и ваши глаза не указали на очевидные
• для защиты противоположного (т.е. многострочного объявления с одной строкой) имеет меньше преимуществ ( "текстовая вертикальная видимость кода" является одноэлементной)

Ответ 14

Это плохая практика, когда вы можете и хотите инициализировать переменные при замедлении. Пример, где это может быть не так плохо:

string a,b;
if (Foo())
{
  a = "Something";
  b = "Something else";
}
else
{
  a = "Some other thing";
  b = "Out of examples";
}

Ответ 15

Как правило, это касается вопросов контроля версий и комментариев, обсуждаемых другими, и я бы применил это в 95% всех случаев. однако есть обстоятельства, когда это имеет смысл, например, если я кодирую графику, и я хочу, чтобы пара переменных представляла координаты текстуры (всегда ссылаясь на условные обозначения как s и t), тогда объявляя их как

int s, t;//координаты текстур

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