[склероз] Как называются следующие конструкции?

> ??=include <stdio.h> 
int main(void) 
??< 
  char n??(5??); 
n??(4??) = '0' - (??-0 ??' 1 ??! 2); 
  printf("%c??/n", n??(4??)); 
  printf("??=??=??=??/n"); 
  while(1); 
??> 

вопросительная конструкция, по ходу

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

while(1);

Говнокод, наверное.

хотя есть среди них и утвердительные, и восклицательные...

Спасибо.

Еще их называют триграфы.

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

Говнокод, наверное.

А как выглядит Ъ бесконечный цикл?

> А как выглядит Ъ бесконечный цикл?

for(;;) конечно же

while(1) красивше.

>А как выглядит Ъ бесконечный цикл?

loop_123:
...
Комманды;
goto loop_123;

Инфа 100%

>А как выглядит Ъ бесконечный цикл?
Меня скорее интересует вопрос, зачем он здесь. Да и for(;;) красивее же.

Кто ж его знает зачем, вестимо не просто так.
Может составить опрос, про предпочитаемые формы записи?

> for(;;) конечно же

любой фор можно переписать как while(1) с проверками внутри

следовательно, фор - это синтаксический сахар, призванный скрыть от нас ужасную правду :))

Триграфами они называются. А ещё и диграфы бывают. Подробности в вики.

you sooo slow, 790.

Ну и на кой хрен нужны такие конструкции???

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

>за любое использование goto

Что, вообще любое? А если подумать?

учитывая, что разговор про си - да, любое.

Я знаю :3

>учитывая, что разговор про си - да, любое.

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

>Даже в тех случаях где оно явно упростит код?

вам знакомо понятие «моветон»?

Не использовать goto, только потому что кто-то сказал что это плохо? Плохо - это делать сложный запутанный код. goto этому очень способствует, но в некоторых случаях может и наооборот упростить код.

пример такого кода, пожалуйста.

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

такая тема тут уже была http://www.linux.org.ru/forum/development/3937702

Я уже написал выше. Обработка ошибок.

Еще может пригодится для выхода из нескольких циклов сразу. В Java такая возможность есть, в С придется использовать goto, либо вводить дополнительные флаги, которые только усложнят программу.

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

>его использование всегда можно обойти другими штатными средствами с наименьшими потерями

Ну конечно, есть longjmp, вот только я не уверен что это меньшее зло чем goto.

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

вместо if (!malloc()) goto bad_malloc; сделать if (!malloc()) return bad_malloc(); где bad_malloc() обрабатывает и возвращает соответствующий результат.

такая тема тут уже была http://www.linux.org.ru/forum/development/3937702

классный тред, не видел. :) тогда не будем продолжать,и пусть отрывание рук за goto будет моим имхо.

bad_malloc предыдущие malloc не сможет освободить.

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

bad_malloc предыдущие malloc не сможет освободить

с goto в таком случае придётся сделать целую сеть из меток, по которым придётся бегать. лучше уж

if (a=malloc())
     { код }
else
     { free_a(); error(1) }

if (b=malloc())
     { код }
else
     { free_b(); free_a(); error(2) }

if (c=malloc())
     { код }
else
     { free_c(); free_b(); free_a(); error(3) }

if (a=malloc())
     { код }
else
     goto bad_a;

if (b=malloc())
     { код }
else
     goto bad_b;

if (c=malloc())
     { код }
else
     goto bad_c;

bad_a: free_a(); error(1); goto go_on;
bad_b: free_b(); free_a(); error(2); goto go_on;
bad_c: free_c(); free_b(); free_c(); error(3); goto go_on;

go_on: { код }

и вообще для таких целей есть try-catch (С++ уже правда)

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

Я имел в виду вот такое:

 
int* a = NULL; 
int* b = NULL;

if (!(a = malloc())) 
    goto error;

if (!(b = malloc())) 
    goto error;

/* Код */

return 0; 

error:

free(a); 
free(b); 
return -1; 

я это и описал, только более расширенно. конкретно для этого кода напрашивается:

int* a = NULL;  
int* b = NULL; 

if (!((a=malloc())||(b=malloc())))
{    
    error(a, b);
    return -1;
}

/* Код */ 
 
return 0;

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

> while(1) красивше.

И даёт варнинг «conditional expression is constant» (по крайней мере, в Visual C; в gcc, наверно, тоже)

Не, не так. Вот так:

if (a=malloc()) 
     { код } 
else 
     goto bad_a; 
 
if (b=malloc()) 
     { код } 
else 
     goto bad_b; 
 
if (c=malloc()) 
     { код } 
else 
     goto bad_c; 

{код}

return true;

bad_c: free_b();
bad_b: free_a();
bad_a: 

return false;

> if (!((a=malloc())||(b=malloc())))

Это ужасно.