Здравствуйте, Пацак, Вы писали:

П> То есть вычислить шаг цикла в рантайме я не могу? В печку такой язык! (с) проф. Преображенский.

Так вот кто был первым падонком? "Фтопку", понимаешь!

Кодт wrote:
> Здравствуйте, Пацак, Вы писали:
>
> П> То есть вычислить шаг цикла в рантайме я не могу? В печку такой язык!
> (с) проф. Преображенский.
>
> Так вот кто был первым падонком? "Фтопку", понимаешь!

Не надо грязи!! У Булгакова Преображенский был грамотным, и этого не
скрывал, как некоторые (хотя и не подчёркивал). Кроме того, можно
вспомнить, что он приказал кинуть в печку...

Здравствуйте, Сергей Губанов, Вы писали:

СГ>Существует разница между завершением и прерыванием цикла.
СГ>EXIT — завершает цикл LOOP, но прерывает вложенные в LOOP другие циклы навроде WHILE/REPEAT
СГ>Прервать циклы WHILE/REPEAT можно несколькими способами: HALT(), ASSERT(FALSE), RETURN, LOOP-ный обертывающий EXIT.
СГ>Но завершить циклы WHILE/REPEAT можно только одним единственным способом.

Я рыдалЪ!!! Честно!
Сергей, может поясните чем одно отличается от другого? А заодно прокомментируете следующее словоблудие в вашем стиле:

while (a < 10) {
    ++a;
     if (foo()) break;
}

Имеем два сценария:
1) значение a стало равно 10 и цикл завершился
2) функция foo вернула true и цикл был прерван

Вывод: в C++ имеется только один способ завершить цикл while, и много способов (в т. ч. break) его прервать.

Здравствуйте, raskin, Вы писали:

R>Не надо грязи!! У Булгакова Преображенский был грамотным, и этого не
R>скрывал, как некоторые (хотя и не подчёркивал). Кроме того, можно
R>вспомнить, что он приказал кинуть в печку...

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

Здравствуйте, Сергей Губанов, Вы писали:

СГ>Здравствуйте, Sinclair, Вы писали:

S>>Покажите мне любой другой перегружаемый оператор, который бы с первого взгляда ассоциировался с конкатенацией.

СГ>str1 := str2 << str3;

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

Гм...
Вы решили перегнать Windows vs Linyx

Автор: VCoder
Дата: 28.05.03

?

Здравствуйте, Sinclair, Вы писали:

S>Тогда бы он, возможно, назывался по другому.

Объясните все-таки, как из написания или значения слова delete следует отсутствие у оператора delete возвращаемого значения?

F>>Нет. Второй пример лучше.
S>Ок. Фраза "Отправь по почте создать документ" ухо не режет? В сравнении с "Отправь по почте новый документ"?

Создай документ. Отправь его по почте.

Открой файл. Запиши в него данные.

Создай окно. Нарисуй на нем картинку.

F>>Почему для открытия файла, для создания окна, объекта ядра (мутекс, событие) и проч. прекрасно подходит глагол, а для создания объекта — только прилагательное?
S>Гм. А кто сказал, что он прекрасно подходит?

Все неправы, один Страуструп прав? Глагол подходит потому, что

1. Обозначает действие, которое в данном случае и производится — создание объекта.

2. Обладает противоположным смыслом с обратным действием — разрушением (удалением) объекта, которое тоже обозначается глаголом.

Интересно, если бы "левая пятка Страуструпа" захотела создавать объекты ключевым словом "green" (а что, новый, еще "зеленый" объект), а удалять, скажем, "explode", этому бы тоже отыскали глубокое идеологическое обоснование? Кстати, explode возвращал бы значение?

S>Чем создается берклеевский сокет?

Давайте еще найдем глубокое обоснование отсутствию буквы 'e' в системном вызове creat().

S>Учти, что все эти чудесные глаголы жили во времена процедурного программирования. Когда мы открываем файл в стиле nix или winapi, ни о каком создании речь не идет.

winapi: CreateFile().

S>В OOP мы просим дать нам новый файловый поток.

В каком OOP? В языке C++ и его наследниках, вы хотите сказать? А вот например, в Eiffel объект создается ключевым словом create. Он уже не относится OOP?

F>>В чем различие контекстов? И там и там создается объект.
S>Ну и что? выражение new Type() читается "новый экземпляр типа Type". В то время как вызов фабрики является командой "создай новый объект".

_Читается_ — да, как "новый". Потому что так написано. Про это и речь. Было бы написано "create Type()", читалось бы "создай".

F>>Кстати, new, если его переопределить, может и не создавать _новый_ объект, а вернуть что-нибудь закэшированнное.
S>Вот именно. Он возвращает новый объект. Не обязательно создавая eго.

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

F>>Не вижу, как из значения или написания слова "delete" следует отсутствие возвращаемого значения.

Так все таки?


S>Делается неверное умозаключение. Я очень удивлюсь, если сложение будет обозначаться чем-то, кроме +. Однако, из этого не следует, что все "+" — это сложение. Как правило, мозг программиста не настолько забит математикой, чтобы он фанатично требовал от плюса, не обведенного защитным кружочком, коммутативности во всех ситуациях.

Вот и печалит пренебрежение "программиста" к математике.

S>Ни разу не видел программиста, ожидавшего от "World!" + "Hello," того же результата, что и "Hello," + "World!". Имхо, проблема является целиком надуманной.

Эквивалентно ли a + b и b + a? Речь, естественно, не про константы.

F>>Я бросил читать Страуструпа еще в прошлом веке.
S>Напрасно. Если есть желание понять, что и почему в С++, то имеет смысл почитать первоисточники, а не задавать риторические вопросы в темноту .

У меня нашлись более интересные книги. Когда они закончатся, вернусь к Страуструпу. На самом деле я давно хотел прочитать эту книгу, но покупать не хотелось, в сети с налету не нашел, а потом стало не до него. Будет время, прочту.

F>>Тем не менее, как пользователь языков программирования, я вижу: в Haskell и ML произвольный оператор определить можно, и никакой трагедии из этого не делают.
S>Зато в Haskell и ML нельзя сделать много чего из С++. Нельзя вот так просто брать и переносить что-то из одного языка в другой.

Не хочу затевать спор, но, во-первых, не "нельзя", а "трудно", а во-вторых, мы же говорим про синтаксис, а не про то, что можно сделать в одном Тюринг-полном языке и нельзя в другом.

Кодт wrote:

> C>"Новые процессоры Intell Pentium 3647 такие быстрые, что выполняют
> C>бесконечный цикл всего за 6 секунд!" (с) анекдот.
> Кстати, интересно: как /должен/ отреагировать пень с предсказанием на
> такой код
>
>@@infinite: jmp @@infinite
>
Как все уважающие себя процессоры — повиснуть до прихода прерываний.

Я помню, что Винда 9х намертво вешалась от:

cli
f: jmp f

А Винду 95 можно было повесить даже:

cli
hlt

--
С уважением,
Alex Besogonov (alexy@izh.com)

faulx wrote:

> S>Тогда бы он, возможно, назывался по другому.
> Объясните все-таки, как из написания или значения слова delete следует
> отсутствие у оператора delete возвращаемого значения?

Вам это по-моему уже раза два сказали. Но раз уж вам так хочется, то вот
мой подарок:

template<class T> bool destruct(T *ptr)
{
    delete ptr;
    return true;
}

Теперь лучше?

> Все неправы, один Страуструп прав? Глагол подходит потому, что

Кто "все"? Может один только faulx?

> 1. Обозначает действие, которое в данном случае и производится —
> создание объекта.

new — это _выражение_, возвращающее новый объект. delete — это
_оператор_, уничтожающий объект по указателю.

> 2. Обладает противоположным смыслом с обратным действием — разрушением
> (удалением) объекта, которое тоже обозначается глаголом.
> Интересно, если бы "левая пятка Страуструпа" захотела создавать
> объекты ключевым словом "green" (а что, новый, еще "зеленый" объект),
> а удалять, скажем, "explode", этому бы тоже отыскали глубокое
> идеологическое обоснование?

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

В отличие от Виртовских поделок процесс разработки С++ открыт и публичен.

ЗЫ: как смешно читать нападки на С++ Каждый раз находятся либо
абсолютно мелочные моменты, которые никто и не замечает, либо заезженные
"висячие указатели"/утечки памяти/...

--
С уважением,
Alex Besogonov (alexy@izh.com)

Здравствуйте, Сергей Губанов:

Ну и баян!
А вот такие конструкции, не прокатывают?


(1)

while(a)x();

(2)

while(true){
    x();
    if(a) {y(); break;}
    z();}

и далее в этом же духе

Здравствуйте, Cyberax, Вы писали:

>> S>Тогда бы он, возможно, назывался по другому.
>> Объясните все-таки, как из написания или значения слова delete следует
>> отсутствие у оператора delete возвращаемого значения?

C>Вам это по-моему уже раза два сказали. Но раз уж вам так хочется, то вот
C>мой подарок:
C>

C>template<class T> bool destruct(T *ptr)
C>{
C>    delete ptr;
C>    return true;
C>}
C>

C>Теперь лучше?

Видимо, я не очень доходчиво выражаю свои мысли. Спрашиваю в очередной раз. Было сказано: "если бы delete возвращал значение, он назывался бы по-другому". Из этого я заключил, что существует какая-то неведомая мне связь между _словом_ delete и тем фактом, что обозначаемый этим словом оператор не имеет права возвращать значения. Я пытаюсь выяснить, в чем же заключается эта связь. Как назывался бы оператор удаления объекта, если бы он возвращал значение? На конкретном примере — если бы он назывался, скажем, explode, возвращал бы он значение или нет?

>> Все неправы, один Страуструп прав? Глагол подходит потому, что

C>Кто "все"? Может один только faulx?

Вместе с авторами POSIX и WinAPI.

>> 1. Обозначает действие, которое в данном случае и производится —
>> создание объекта.

C>new — это _выражение_, возвращающее новый объект. delete — это
C>_оператор_, уничтожающий объект по указателю.

1. Вызов open() — это тоже выражение, возвращающее дескриптор открытого (или созданного) файла.

2. delete тоже мог бы возвращать значение (пока мне не докажут обратного)

3. new производит _действие_, поэтому его логичнее обозначить глаголом.

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

>> 2. Обладает противоположным смыслом с обратным действием — разрушением
>> (удалением) объекта, которое тоже обозначается глаголом.
>> Интересно, если бы "левая пятка Страуструпа" захотела создавать
>> объекты ключевым словом "green" (а что, новый, еще "зеленый" объект),
>> а удалять, скажем, "explode", этому бы тоже отыскали глубокое
>> идеологическое обоснование?

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

Это произошло бы до создания комитета по стандартизации. Почему на green/explode мат был бы, а на new/delete не было? Есть этому логические обоснования?

C>В отличие от Виртовских поделок процесс разработки С++ открыт и публичен.

new и delete не были введены в язык в результате открытого и публичного процесса.

C>ЗЫ: как смешно читать нападки на С++

Форум такой, так что стараемся.

C>Каждый раз находятся либо
C>абсолютно мелочные моменты, которые никто и не замечает, либо заезженные
C>"висячие указатели"/утечки памяти/...

Тема обязывает.

Кстати, кроме new/delete я сделал еще кое-какие замечания, например про

LongClassName *obj = new LongClassName(...)

Все молчат. Нечем крыть?

faulx wrote:

> From: *faulx* </Users/Profile.aspx?uid=30417>
> </search/?group=33> </Users/Private/AddFav.aspx?mid=1243814>
> <NewMsg.aspx?gid=33> <NewMsg.aspx?mid=1243814> <?mid=1243814>
> <Message.aspx?mid=1243814#1243814> <NewMsg.aspx?mid=1243814&edit=1>
> <Private/Self.aspx?mid=1243814>
>
> Здравствуйте, Cyberax, Вы писали:
>
>>> S>Тогда бы он, возможно, назывался по другому.
>>> Объясните все-таки, как из написания или значения слова delete следует
>>> отсутствие у оператора delete возвращаемого значения?
>
> C>Вам это по-моему уже раза два сказали. Но раз уж вам так хочется, то
> вот
> C>мой подарок:
> C>
>
>C>template<class T> bool destruct(T *ptr)
>C>{
>C> delete ptr;
>C> return true;
>C>}
>C>
>
>
> C>Теперь лучше?
>
> Видимо, я не очень доходчиво выражаю свои мысли. Спрашиваю в очередной
> раз. Было сказано: "если бы delete возвращал значение, он назывался бы
> по-другому". Из этого я заключил, что существует какая-то неведомая
> мне связь между _словом_ delete и тем фактом, что обозначаемый этим
> словом оператор не имеет права возвращать значения. Я пытаюсь
> выяснить, в чем же заключается эта связь. Как назывался бы оператор
> удаления объекта, если бы он возвращал значение? На конкретном примере
> — если бы он назывался, скажем, explode, возвращал бы он значение или нет?
>
>>> Все неправы, один Страуструп прав? Глагол подходит потому, что
>

> C>Кто "все"? Может один только faulx?
> Вместе с авторами POSIX и WinAPI.

POSIX зародился в седой древности, так что к нему претензий нет. А
WinAPI созад MS.

> C>new — это _выражение_, возвращающее новый объект. delete — это
> C>_оператор_, уничтожающий объект по указателю.
> 1. Вызов open() — это тоже выражение, возвращающее дескриптор
> открытого (или созданного) файла.

В С++ его можно было бы записать как:

file *fl=new File(....);

Просто в С нет конструкторов.

> 2. delete тоже мог бы возвращать значение (пока мне не докажут обратного)

А зачем? В С++ есть такая вещь — автоматические объекты, их деструкторы
вызываются автоматически при выходе за границы диапазона. То есть:

{
    file fl(...);
}; //Здесь будет вызван деструктор fl.

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

> 3. new производит _действие_, поэтому его логичнее обозначить глаголом.

Ладно, специально для вас:

#define new create

> C>Нет, такие предложения бы отклонили в комитете по стандартизации, а до
> C>этого пользователи написали бы в адрес Страуструпа гору мата.
> Это произошло бы до создания комитета по стандартизации.

Это не отменило бы горы мата в письмах к Страуструпу. С++ разрабатывался
публично с первого своего дня жизни.

> Почему на green/explode мат был бы, а на new/delete не было? Есть
> этому логические обоснования?

Есть. Никого new/delete не напрягает (кстати, new быстрее писать, чем
create).

> C>В отличие от Виртовских поделок процесс разработки С++ открыт и
> публичен.
> new и delete не были введены в язык в результате открытого и
> публичного процесса.

Они были введены Страуструпом и что-то я не помню дальнейших возражений
против них. Зато обсуждались такие вещи как renew (перемещающий new),
например.

> Кстати, кроме new/delete я сделал еще кое-какие замечания, например про
>
>LongClassName *obj = new LongClassName(...)
>
> Все молчат. Нечем крыть?

В новом С++0x можно будет делать так:

auto *obj=new LongClassName(...);

Тип переменной obj будет автоматически выведен из типа правой части.

--
С уважением,
Alex Besogonov (alexy@izh.com)

Здравствуйте, faulx, Вы писали:

F>3. new производит _действие_, поэтому его логичнее обозначить глаголом.

Попробуй прочитать выражение:

Foo tmp = new Foo();

Переменной типа Foo присвоить новый объект типа Foo
А теперь подставь туда "создать". Ну как, звучит?

F>Кстати, кроме new/delete я сделал еще кое-какие замечания, например про

F>

F>LongClassName *obj = new LongClassName(...)
F>

Это действительно не очень хорошо, спорить не с чем

M>>Ладно, эксперта по поиску в Гугле вызывали? Тута я

SJA>Тссс ! Это Серёга должен нервничать, и искать ссылки, приводить доказательства. А мы будем степенно возражать
SJA>"Нет, это не так." И ждать дальнейших доказательств.



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

Здравствуйте, Cyberax, Вы писали:

>> C>Кто "все"? Может один только faulx?
>> Вместе с авторами POSIX и WinAPI.

C>POSIX зародился в седой древности, так что к нему претензий нет. А
C>WinAPI созад MS.

А я надеялся, что вы припишите их создание мне.

>> C>new — это _выражение_, возвращающее новый объект. delete — это
>> C>_оператор_, уничтожающий объект по указателю.
>> 1. Вызов open() — это тоже выражение, возвращающее дескриптор
>> открытого (или созданного) файла.

C>В С++ его можно было бы записать как:
C>

C>file *fl=new File(....);
C>

Ну и что? Здесь происходит _создание_ объекта File. Почему _создание_ обозначается не глаголом, а прилагательным?

>> 2. delete тоже мог бы возвращать значение (пока мне не докажут обратного)

C>А зачем?

А зачем возвращают значения close() и IUnknown::Release()? А доказательства, что невозврат значения как-то связан с названием оператора удаления объекта, мне не дождаться?

C>В С++ есть такая вещь — автоматические объекты, их деструкторы
C>вызываются автоматически при выходе за границы диапазона. То есть:
C>

C>{
C>    file fl(...);
C>}; //Здесь будет вызван деструктор fl.
C>

C>То есть результат деструктора читать некому. Более того, резултат
C>деструктора бессмысленен при уничтожении массива объектов.

1. С++ я знаю.

2. Здесь нет new/delete (по крайней мере, снаружи), так что пример не про то.

>> 3. new производит _действие_, поэтому его логичнее обозначить глаголом.

C>Ладно, специально для вас:
C>

C>#define new create
C>

1. C++ я знаю.

2. Такое переопределение создаст больше проблем, чем решит.

3. Разговор не про то, _как_, а про то, _почему_.

>> Почему на green/explode мат был бы, а на new/delete не было? Есть
>> этому логические обоснования?

C>Есть. Никого new/delete не напрягает

Это же не доказательство. Надо сохраниться, отмотать время назад и посмотреть, будет ли мат. Какие есть _внутренние_ доказательства того, что green/explode объективно хуже new/delete?

C>Они были введены Страуструпом и что-то я не помню дальнейших возражений
C>против них. Зато обсуждались такие вещи как renew (перемещающий new),
C>например.

Move constructors? Да, это тоже большая западня C++, но к синтаксису не относится, поэтому про нее я не писал. (Про MOJO знаю).

>> Кстати, кроме new/delete я сделал еще кое-какие замечания, например про
>>
>>LongClassName *obj = new LongClassName(...)
>>
>> Все молчат. Нечем крыть?

C>В новом С++0x можно будет делать так:
C>

C>auto *obj=new LongClassName(...);
C>

C>Тип переменной obj будет автоматически выведен из типа правой части.

Кстати, про это я знал. Маленькая провокация

Здравствуйте, Дарней, Вы писали:

Д>Попробуй прочитать выражение:
Д>

Д>Foo tmp = new Foo();
Д>

Д>Переменной типа Foo присвоить новый объект типа Foo
Д>А теперь подставь туда "создать". Ну как, звучит?

Да. Также как:

File f = open();
Window w = create_window();

СГ>Поэтому следующий код корректен
СГ>

СГ>WHILE отмерено меньше семи раз DO отмерять END;
СГ>Отрезать (* Режем не делая более ни каких проверок.  Мы уже не спрашиваем можно ли отрезать, а просто режем!!! *)

СГ>REPEAT узнавать где брод DO узнал END
СГ>Соваться в воду (* Суемся в воду не делая более ни каких проверок. Просто суемся!!! *)
СГ>

СГ> В Си while/do можно завершить несколькими способами (+break, +goto), поэтому они не могут называться WHILE/REPEAT циклами.
СГ>Для Си код аналогичный вышепреведенному, вообще говоря может быть не корректен, так как причина завершения сишных циклов while/do с break и goto на момент написания и компиляции программы не известна. Истинная причина завершения сишных while/do с break и goto может быть выяснена только динамически во время работы программы.

Что за бред?

int i = 0;
while(i < 7)
{
   measure();
}

cut();

И еще раз. То, что вы называете определением циклов — это, извините, плод вашего больного воображения. Вы бы хоть раз сходили по ссылкам, что тут приводят:
— Control flow:Minimal structured control flow, Loops
— Structured programming
— While loop
— For loop

Здравствуйте, faulx, Вы писали:

F>Да. Также как:

F>

F>File f = open();
F>Window w = create_window(); 
F>

Это в процедурном стиле — более старом, чем ООП, соответственно и названия функций не самые удачные. С таким же успехом можно придраться к тому, что в выньАПИ файлы открывают функцией CreateFile

Здравствуйте, Дарней, Вы писали:

F>>

F>>File f = open();
F>>Window w = create_window(); 
F>>

Д>Это в процедурном стиле — более старом, чем ООП, соответственно и названия функций не самые удачные. С таким же успехом можно придраться к тому, что в выньАПИ файлы открывают функцией CreateFile

Так все-таки, необходимость, чтобы создание объекта обозначалось прилагательным, следует из необходимости соблюдать стиль ООП, или из того, что создание объекта — это выражение, а не оператор? Если из второго, то open() и create_window() — тоже выражения. Это я и хотел показать приведенными примерами.

Кстати, к языкам с GC такой претензии нет. В Java/C#/Smalltalk объекты тоже создаются new, но там нет обратной операции, поэтому все нормально. А тезис мой такой: противоположные по смыслу действия должны обозначаться противоположными по смыслу словами (одной и той же грамматической категории). Есть возражения против этого тезиса?

PS. А насчет CreateFile() как раз все понятно. Создается объект ядра "файл", связанный с объектом файловой системы.

Здравствуйте, Пацак, Вы писали:

СГ>>step — константа известная на момент компиляции (с нулем просто не скомпилируется).

П> То есть вычислить шаг цикла в рантайме я не могу?

В FOR — нет. Это, видимо, предусмотрено для возможной оптимизации. Иначе FOR ну вообще бы ни чем не отличался от WHILE. А зачем в точности дублировать то что и так уже есть? Используйте WHILE...