>[оверквотинг удален]
> что ты не кодил на ассемблере. Возьмём, скажем, понятие "переменная". В
> ассемблере такого понятия, по-хорошему, нет. Там есть регистры, есть стек, есть
> RAM. И ты перекладываешь значения с места на место. Некоторые места
> в RAM могут иметь вполне определённую семантику, и такие места можно
> назвать переменными, но подчастую работа с этими переменными сводится к тому,
> чтобы забрать оттуда значение, что-то с ним сделать, положить обратно. В
> C же, переменная -- это переменная, она может располагаться на стеке,
> в куче, в статической памяти, в регистре, иногда это определяется контекстом,
> но очень часто компилятор за тебя решает, когда и какая переменная
> будет представляться регистром, а когда ячейкой стека.Вообще опыт программирования на ассемблере вполне себе имею и до сих пор приходится периодически или писать ассемблерные вставки для C, а то и чисто ассемблерный код для 86-ой архитектуры, или смотреть дизассемблированный код. Ассемблер даёт возможность объявлять именованные ячейки памяти - на самом деле метки присвоенные ячейкам. По крайней мере для 86 архитектуры, как для для разных там masm-ов/tasm-ов, так и для разных gas-ов это справедливо. Опять-же для tasm-ов была возможность даже объявлять переменные на стеке в соответствии с определённой callcing convention, и тогда написав что-то типа
mov ax,myparam1
в коде можно было получить что-то типа:
mov ax,[bp + 7]
Так-что ассемблер ассемблеру рознь - некоторые даже позволяли объявлять структуры и прочие высокоуровневые абстракции.
А вообще в C, как и в ассемблере приходится явно заявлять класс хранения переменной. И даже намекнуть компилятору, что было-бы неплохо вот эту переменную хранить в регистре, ну а он может с этим согласиться, а может и нет.
> А типы? В асме нет типов, тип значения определяется операцией, которую ты
> выполняешь. Если add -- это целочисленное сложение 32-х битных целых, то
> она будет складывать 32-х битные флоаты как целые числа. В C
> тип определяется типом переменной или другого источника/приёмника откуда ты берёшь или
> куда ты кладёшь значение. Если ты используешь операцию + для сложения
> целых, то она сложит целые. Если ты используешь её для сложения
> float'ов, она сложит флоаты. При этом при необходимости типы аргументов будут
> приведены до соответствия друг-другу.
С float-ами соглашусь - там это специализированные команды сопроцессора, по крайней мере опять-же для 86-ой архитектуры. А вот для целочисленных это не так - там (в tasm/masm, а, если не ошибаюсь, с недавнего времени и в gas), add складывает как 8-ми битные, так и 16-ти и 32-х битные целые значения, как знаковые так и беззнаковые, вроде как одной и той-же командой (понятно, что для процессора эти команды разные, но для программиста - нет), а, опять-же в каких-то архитектурах типа 86 даже может прибавлять к регистру содержимое памяти.
> Особенно эти сишные типы заметны на указателях:
> для асма нет разницы между целым значением, void* и char*. Ты
> когда пишешь на асме думаешь об указателях как о целых числах.
> В C же, указатель с некоторой натяжкой можно назвать целым числом,
> но в зависимости от типа указателя операция сложения будет выдавать разные
> значения. (char*)0 + 1 даст 1, а (int*)0 + 1 даст
> 4.
С этим - согласен. Хотя его предок, B, если правильно помню вполне себе был безтиповым, т.е. у него, если правильно понимаю, был тип int и был, формально, указатель void*, правда как он там с переменными с плавающей запятой обходился не знаю, возможно для той архитектуры их просто не было.
> В C есть функции -- это тоже абстракции. В ассемблере есть код
> и есть данные, деление между ними условно -- ты можешь сделать
> jmp на данные, или прочитать байт кода в регистр. В асме
> ты можешь создавать функции, но при этом ты можешь сделать call
> в середину функции, или jmp из одной функции в другую. И,
> я отмечу, это не всегда глупость, это может быть вполне осмысленным
> и полезным действием. Скажем, tail call'ы так и делаются -- вместо
> call func/ret, мы делаем jmp func. Функции с несколькими точками входа
> тоже не редкость в асме.
Должен-же он был чем-то отличаться от ассемблера, кроме синтаксиса. Да и заявлялось, что C - это язык высокого уровня, и до сравнительно недавнего времени так и было. Это теперь его уже считают языком среднего уровня - выше ассемблера, но ниже всех остальных.
> Абстракции есть в любой проблеме, о которой ты в состоянии думать. Если
> ты не видишь этих абстракций, значит ты недостаточно глубоко копнул.
Если Вы сразу не поняли, то то сообщение был сарказм. Постараюсь в следующий раз как-то дополнительно помечать такого рода сообщения. Впрочем, всё-равно было интересно Вас почитать. Спасибо.
