Подтвердить что ты не робот

Рекомендации по улучшению кода

Какие рекомендации вы придерживаетесь для улучшения общего качества вашего кода? У многих людей есть правила о том, как писать код на С++, который (предположительно) затрудняет ошибку. Я видел, как люди настаивали на том, что за каждым оператором if следует блок скобок ({...}).

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

Чтобы получить мяч, я расскажу несколько, чтобы начать с:

  • Всегда используйте фигурные скобки после каждого оператора if/else (см. выше). Обоснование этого заключается в том, что не всегда легко определить, является ли один оператор фактически одним оператором или макросом препроцессора, который расширяется до более чем одного оператора, поэтому этот код сломается:
    // top of file:
    #define statement doSomething(); doSomethingElse

    // in implementation:
    if (somecondition)
        doSomething();

но если вы используете фигурные скобки, то он будет работать, как ожидалось.

  • Использовать макросы препроцессора для условной компиляции ТОЛЬКО. макросы препроцессора могут вызывать все виды ада, поскольку они не позволяют использовать правила С++. Я много раз заходил на мель из-за макросов препроцессора с общими именами в файлах заголовков. Если вы не будете осторожны, вы можете причинить всевозможные хаосы!

Теперь вам.

4b9b3361

Ответ 1

Несколько моих личных фаворитов:

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

Выйдите из бизнеса управления памятью. Научитесь использовать интеллектуальные указатели: std::auto_ptr, std::tr1::shared_ptr (или boost::shared_ptr) и boost::scoped_ptr. Изучите различия между ними и когда использовать один против другого.

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

Ответ 2

  • Удалить ненужный код.

Вот и все.

Ответ 3

  • Используйте и применяйте общий стиль и рекомендации по кодированию. Обоснование: каждый разработчик в команде или в фирме может читать код без каких-либо отвлекающих факторов, которые могут возникнуть из-за разных стилей скобок или аналогичных.
  • Регулярно выполняйте полную перестройку всей исходной базы (т.е. ежедневно стройте или создавайте после каждой проверки) и сообщайте о любых ошибках! Обоснование: источник почти всегда находится в пригодном для использования состоянии, и проблемы обнаруживаются вскоре после того, как они "реализованы", где решение проблемы дешево.

Ответ 4

Включите все предупреждения, которые вы можете стоять в своем компиляторе (gcc: -Wall - хороший старт, но не включает все, чтобы проверить документы) и сделать их ошибки, поэтому вам нужно их исправить (gcc: -Werror).

Ответ 5

Руководство по стилю Google, упомянутое в одном из этих ответов, довольно прочное. В нем есть какие-то бессмысленные вещи, но это лучше, чем плохо.

Sutter и Alexandrescu написал приличную книгу на эту тему, называемую С++ Coding Standards.

Вот некоторые общие советы от lil 'ole me:

  • Ваш стиль отступов и брекетинга ошибочен. Так и все остальные. Поэтому следуйте стандартам проекта для этого. Проглотите свою гордость и настройте свой редактор, чтобы все было как можно более согласованным с остальной частью кодовой базы. Это действительно очень раздражает необходимость читать код, который отступал непоследовательно. Тем не менее, брекетинг и отступы не имеют ничего общего с "улучшением вашего кода". Это больше касается улучшения вашей способности работать с другими.

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

  • Экспресс-логика как можно более простой. Похоже, что здесь, кажется, ошибались такие предложения, как "положить константы в левой части сравнений". Они очень популярны, но для англоговорящих они часто нарушают логический ход программы до этих чтений. Если вы не можете доверять себе (или вашему компилятору) правильное сопоставление равенства, тогда, во всяком случае, используйте трюки, подобные этому. Но вы жертвуете ясностью, когда вы это делаете. Также под этой категорией есть такие вещи, как... "Есть ли у моей логики 3 уровня отступов? Может быть, это проще?" и скользящий аналогичный код в функции. Возможно даже разделение функций. Требуется опыт написания кода, который изящно выражает основную логику, но стоит над этим работать.

Это были довольно общие. Для конкретных советов я не могу сделать намного лучшую работу, чем Саттер и Александрескку.

Ответ 6

В операторах if поставить константу слева i.e.

if( 12 == var )

не

if( var == 12 )

Избегайте, если вы пропустите ввод '=', тогда он станет назначением. В верхней версии компилятор говорит, что это невозможно, в последнем он запускается, а if всегда верно.

Я использую фигурные скобки, если каждый раз, когда они не находятся на одной строке.

if( a == b ) something();
if( b == d )
{
    bigLongStringOfStuffThatWontFitOnASingleLineNeatly();
}

Открытые и закрытые фигурные скобки всегда получают свои собственные линии. Но это, конечно же, личное соглашение.

Ответ 7

Только комментарий, когда нужно только объяснить, что делает код, где чтение кода не может сказать вам то же самое.

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

Ответ 8

  • Использовать последовательное форматирование.
  • При работе с устаревшим кодом используйте существующий стиль форматирования, особенно. стиль скобки.
  • Получить копию книги Скотта Мейера Эффективный С++
  • Получите копию книги Стива MConnell Code Complete.

Ответ 9

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

Ответ 10

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

т

for(int i=0; i<=arr.length; i++) {
  arr[i].conf() //confirm that every username doesn't contain invalid characters
}

Должно было что-то походить больше

for(int i=0; i<=activeusers.length; i++) {
  activeusers[i].UsernameStripInvalidChars()
}

Ответ 12

  • Используйте вкладки для отступов, но выравнивайте данные с пробелами Это означает, что люди могут решить, сколько отступ, изменив размер вкладки, но также и то, что вещи остаются выровненными (например, вам может понадобиться все "=" в вертикальной строке при присваивании значения структуре)

  • Allways использует константы или встроенные функции вместо макросов, где возможно

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

  • Если что-то больше, чем около 80 колоний, разделите его на несколько строк, например

    if(SomeVeryLongVaribleName != LongFunction(AnotherVarible, AString) &&
       BigVaribleIsValid(SomeVeryLongVaribleName))
    {
        DoSomething();
    }
    
  • Перегружать только операторы, чтобы заставить их делать то, что ожидает пользователь, например, перегрузка операторов + и - для 2dVector прекрасна.

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

Ответ 13

  • установление кодировки и включение всех участников в соответствие с конвенцией (вы не захотите читать код, который требует, чтобы вы выяснили, где следующий оператор/выражение, потому что оно не имеет отступов должным образом)
  • постоянный рефакторинг вашего кода (получить копию Рефакторинга, Мартин Фаулер, плюсы и минусы подробно описаны в книге)
  • напишите свободно связанный код (избегайте писать комментарий, написав самоочевидный код, слабо связанный код, как правило, легче управлять/адаптировать к изменениям).
  • если возможно, unit test ваш код (или если вы достаточно мачо, TDD.)
  • релиз рано, релиз часто
  • избегать преждевременной оптимизации (профилирование помогает в оптимизации)

Ответ 14

Здесь вы можете использовать pre-increment вместо post-increment.

Ответ 15

Я использую PC-Lint для своих проектов на С++ и особенно люблю то, как он ссылается на существующие публикации, такие как рекомендации MISRA или "Эффективный С++" Скотта Мейерса и "Более эффективный С++". Даже если вы планируете писать очень подробные обоснования для каждого правила, которое проверяет инструмент статического анализа, рекомендуется указывать на созданные публикации, которым доверяет ваш пользователь.

Ответ 16

Вот самый важный совет, который я дал гуру С++, и это помогло мне в нескольких критических случаях найти ошибки в моем коде:

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

С этими 2 правилами компилятор скажет вам бесплатно, где в вашем коде логика ошибочна!

Ответ 18

Посмотрите на это через шесть месяцев

Ответ 19

убедитесь, что вы отступали правильно

Ответ 20

Хм - я, вероятно, должен был быть более конкретным.

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

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

Ответ 21

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

  • если вы получаете необработанный указатель, вы ничего не владеете. Вам разрешено использовать указатель, любезно предоставленный вашим абонентом, который гарантирует, что плательщик останется в живых дольше, чем вы.
  • если вы получаете weak_ptr, вы не владеете плательщиком, и, кроме того, он может исчезнуть в любое время.
  • если вы получаете shared_ptr, вы владеете объектом вместе с другими, поэтому вам не нужно беспокоиться. Меньше стресса, но и меньше контроля.
  • если вы получаете auto_ptr, вы являетесь единственным владельцем объекта. Это твое, ты король. У вас есть возможность уничтожить этот объект или передать его кому-то другому (тем самым теряя право собственности).

Я считаю, что auto_ptr особенно силен: в дизайне, если я вижу auto_ptr, я сразу же знаю, что этот объект собирается "блуждать" из одной части системы в другую.

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

Ответ 22

Стандарты кодирования С# и соглашения об именах

Ниже приведены наши стандарты кодирования С#, соглашения об именах и лучшие практики. Используйте их в своих проектах и ​​/или подстраивайте их под свои нужды.

Соглашения и стиль именования

do использовать PascalCasing для имен классов и имен методов.

Почему: совместим с Microsoft.NET Framework и легко читается.

do используйте camelCasing для аргументов метода и локальных переменных.

Почему: совместим с Microsoft.NET Framework и легко читается.

не использовать: использовать венгерскую нотацию или идентификацию другого типа в идентификаторах

Почему: в соответствии с Microsoft.NET Framework и Visual Studio IDE упрощает определение типов (с помощью всплывающих подсказок). В общем, вы хотите избежать указателей типа в любом идентификаторе.

не использовать использовать кривые Caps для констант или переменных только для чтения

Подробнее о "Стандартах кодирования С# и соглашениях об именах" , например, здесь