интервал i = 2;//, что Вы используете в качестве одноразовой строки, когда Вам просто нужно что-то для установки контрольных точек на?

String foo = "bar";

Visual Studio позволяет Вам повредиться на фигурной скобке.

Я делаю то же самое с int значение, но мой фаворит

int y=1;

asm, энергозависимый ("NOP");

В большинстве, если не все отладчики JavaScript можно использовать

debugger;

оператор, который ведет себя как точка останова.

int x = 0;  
x = x;

Console.Writeline(e.Message);

int moo = 42;

Почему мычание? Не знайте, это просто приходит на ум. Почему 42? Почему не был бы Вы выбирать его!

bool breakHere = true;

Это самодокументирует!

Я использую это в C#:

If (Debugger.IsAttached)
    Debugger.Break();

Я бросаю IsAttached так, чтобы, если это не становится удаленным, он не производил производственный код.

Какой смысл того, чтобы ввести код для повреждения? Уже нет ли код, где Вы хотите повредиться? Я просто поместил точку останова на фактическую рассматриваемую строку; мой IDE (Eclipse) остановки прежде, чем выполнить ту строку. Кажется достаточно легким.

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

(void *)"Insert witty comment."

asm { int3 }

Но я - сумасшедший человек :D

i = i;

или любая переменная определяется в объеме.

В C#/VS Вы получаете предупреждение компилятора, таким образом, это - также хороший метод отметить код как не законченный и т.д.

console.write("stop here")

В .NET всегда используют точно, что строка, я понятия не имею, почему, просто имейте в течение многих лет.

Тебя не потребность в одноразовом коде.
Можно поместить точку останова даже внутри "для" объявления цикла;
Углубите курсор "для" объявления цикла и нажмите F9

В Платформе.NET (использующий C# здесь):

System.Diagnostics.Debugger.Break();

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

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>sddb</Title>
      <Shortcut>sddb</Shortcut>
      <Description>
        Code snippet for System.Diagnostics.Debugger.Break()
      </Description>
      <Author>Peter McG</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Code Language="csharp">
        <![CDATA[System.Diagnostics.Debugger.Break();$end$]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Если это - C++ на x86 машине, я просто использую:

__asm int 3

и просто ожидайте исключения для удара. Не должны даже запускаться в отладчике в Windows, или Вы используете хороший ole DebugBreak ().

В C# я повреждаюсь на фигурной скобке конца, и в VB.NET я повреждаю на Конце If/Sub/Function/whatever.

Рассмотрим желаемые свойства. Код должен

1. поддерживать точку останова
2. четко объяснять, что он существует только для точек останова.
3. не должен быть сразу виден пользователю, который его запускает.
4. не влияет на поведение во время выполнения (включая время выполнения) .

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

Я не особо люблю добавлять сборки. Он не переносится и мешает компилятору анализировать окружающий код. Даже если это не работает, это может повлиять на производительность.

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

Я думаю, что лучший код - bool breakpoint_dummy = / * значение ничего не значит * / false; . Он умещается в 80 столбцах, объясняет, что это такое, и если ваш оптимизирующий компилятор не может работать с неиспользуемыми переменными, он (надеюсь?) Скомпилируется в xorl eax, eax , быстрый и небольшой фрагмент. кода (я бы предположил). В общем, нули дешевле единиц; -)

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

Я думаю, что лучший код - bool breakpoint_dummy = / * значение ничего не значит * / false; . Он умещается в 80 столбцах, объясняет, что это такое, и если ваш оптимизирующий компилятор не может работать с неиспользуемыми переменными, он (надеюсь?) Скомпилируется в xorl eax, eax , быстрый и небольшой фрагмент. кода (я бы предположил). В общем, нули дешевле единиц; -)

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

Я думаю, что лучший код - bool breakpoint_dummy = / * значение ничего не значит * / false; . Он умещается в 80 столбцах, объясняет, что это такое, и если ваш оптимизирующий компилятор не может работать с неиспользуемыми переменными, он (надеюсь?) Скомпилируется в xorl eax, eax , быстрый и небольшой фрагмент. кода (я бы предположил). В общем, нули дешевле единиц; -)

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

Я думаю, что лучший код - bool breakpoint_dummy = / * значение ничего не значит * / false; . Он умещается в 80 столбцах, объясняет, что это такое, и если ваш оптимизирующий компилятор не может работать с неиспользуемыми переменными, он (надеюсь?) Скомпилируется в xorl eax, eax , быстрый и небольшой фрагмент. кода (я бы предположил). В общем, нули дешевле единиц; -)

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

Я думаю, что лучший код - bool breakpoint_dummy = / * значение ничего не значит * / false; . Он умещается в 80 столбцах, объясняет, что это такое, и если ваш оптимизирующий компилятор не может работать с неиспользуемыми переменными, он (надеюсь?) Скомпилируется в xorl eax, eax , быстрый и небольшой фрагмент. кода (я бы предположил). В общем, нули дешевле единиц; -)

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

Я думаю, что лучший код - bool breakpoint_dummy = / * значение ничего не значит * / ложь; . Он умещается в 80 столбцах, объясняет, что это такое, и если ваш оптимизирующий компилятор не может работать с неиспользуемыми переменными, он (надеюсь?) Скомпилируется в xorl eax, eax , быстрый и небольшой фрагмент. кода (я бы предположил). В общем, нули дешевле единиц; -)

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

Я думаю, что лучший код - bool breakpoint_dummy = / * значение ничего не значит * / ложь; . Он умещается в 80 столбцах, объясняет, что это такое, и если ваш оптимизирующий компилятор не может работать с неиспользуемыми переменными, он (надеюсь?) Скомпилируется в xorl eax, eax , быстрый и небольшой фрагмент. кода (я бы предположил). В общем, нули дешевле единиц; -)

ll (надеюсь?) скомпилировать в xorl eax, eax , быстрый и небольшой фрагмент кода (я думаю). В общем, нули дешевле единиц; -)

ll (надеюсь?) скомпилировать в xorl eax, eax , быстрый и небольшой фрагмент кода (я думаю). В общем, нули дешевле единиц; -)

В C / C ++ вы можете использовать a no-op:

;

Я всегда делал что-то вроде #define , например (VC ++):

#define NOP __asm{nop}

Это может быть что-то еще для разных платформ, например (gcc):

#define NOP asm("nop")

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

/* insert directives to prevent inlining and optimization */
void nop() {} 

#define NOP (nop())

Его также можно превратить в ничто для сборок, в которых вы этого не хотите:

#define NOP ((void)0)

Подобные вещи могут go везде, где используются typedef, зависящие от платформы, и так далее.