Почему много языков программирования помещает тип *после* имя переменной?
Когда люди спрашивают о замене для Доступа, многие из них только думают о базе данных, но о чем они действительно спрашивают, все другие функции в Доступе. Они обычно не заботятся о том, что использует доступ к базе данных.
Часть функциональности, обеспеченной Доступом: Формы, Здание Запроса, Отчеты, Макросы, управление базой данных и некоторый язык, когда необходимо пойти вне того, что обеспечивают мастера.
SQLite, MySQL и FireBird являются свободными бэкэндами базы данных. Им не встроили те дополнительные Функции доступа в них. Любые свободные альтернативы Доступу требуют Вас комбинирующий что-то как SQLite и язык разработки.
, Вероятно, лучшая бесплатная опция была бы SQLite и Visual Basic 2008 или Express Edition 2008 года C#. Это имело бы тяжелую зависимость во время выполнения, таким образом устанавливание на пустом клиенте могло взять вполне установщик.
действительно нет опции недоступа бесплатно с минимальными требованиями во время выполнения. Мне жаль, что не было.
я буду интересоваться слушанием, если кто-либо будет знать какие-либо хорошие альтернативы.
11 ответов
Как говорит Кейт Рэндалл, существует проблема синтаксического анализа, но это не то, что он описывает. «Незнание, является ли это декларацией или выражением» просто не имеет значения - вам все равно, выражение это или декларация, пока вы все равно не проанализируете все это целиком, после чего двусмысленность будет разрешена.
При использовании контекстно-свободного синтаксического анализатора совершенно не имеет значения, идет ли тип до или после имени переменной. Важно то, что вам не нужно искать пользовательские имена типов, чтобы понять спецификацию типа - вам не нужно понимать все, что было раньше, чтобы понять текущий токен.
Синтаксис Паскаля - это контекст -free - если не полностью, то по крайней мере WRT эту проблему. Тот факт, что имя переменной идет первым, менее важен, чем такие детали, как разделитель двоеточий и синтаксис описаний типов.
Синтаксис C является контекстно-зависимым. Чтобы синтаксический анализатор мог определить, где заканчивается описание типа и какой токен является именем переменной, он должен уже интерпретировать все, что было раньше, чтобы он мог определить, является ли данный токен идентификатора именем переменной или просто другим токеном, способствующим описание типа.
Поскольку синтаксис C зависит от контекста, очень сложно (если не невозможно) выполнить синтаксический анализ с использованием традиционных инструментов генератора синтаксического анализа, таких как yacc / bison, тогда как синтаксис Паскаля легко анализировать с использованием тех же инструментов. Тем не менее, теперь есть генераторы парсеров, которые могут справиться с синтаксисом C и даже C ++. Хотя это неправильно задокументировано или в 1.? выпуск и т. д., мой личный фаворит - Kelbt , который использует LR с возвратом и поддерживает семантическую «отмену» - в основном отмену добавления к таблице символов, когда спекулятивный синтаксический анализ оказывается неверным.
На практике синтаксические анализаторы C и C ++ работают обычно написано вручную, смешивая рекурсивный спуск и анализ приоритета. Я предполагаю, что то же самое применимо к Java и C #.
Между прочим, аналогичные проблемы с контекстной чувствительностью при синтаксическом анализе C ++ создали много неприятностей. « Альтернативный синтаксис функции » для C ++ 0x работает с аналогичной проблемой, перемещая спецификацию типа в конец и помещая ее после разделителя - очень похоже на двоеточие Паскаля для типов, возвращаемых функцией. Это не избавляет от чувствительности к контексту, но принятие этого соглашения, подобного Pascal, делает его немного более управляемым.
который использует LR обратного отслеживания и поддерживает семантическую «отмену» - в основном отмену добавления к таблице символов, когда спекулятивный синтаксический анализ оказывается неверным.На практике синтаксические анализаторы C и C ++ обычно написаны вручную, смешивая рекурсивный спуск и анализ приоритета. Я предполагаю, что то же самое применимо к Java и C #.
Между прочим, аналогичные проблемы с контекстной чувствительностью при синтаксическом анализе C ++ создали множество неприятностей. « Альтернативный синтаксис функции » для C ++ 0x работает для решения аналогичной проблемы, перемещая спецификацию типа в конец и помещая ее после разделителя - очень похоже на двоеточие Паскаля для типов, возвращаемых функцией. Это не избавляет от чувствительности к контексту, но принятие этого паскалевского соглашения делает его немного более управляемым.
который использует LR обратного отслеживания и поддерживает семантическую «отмену» - в основном отмену добавления к таблице символов, когда спекулятивный синтаксический анализ оказывается неверным.На практике синтаксические анализаторы C и C ++ обычно написаны вручную, смешивая рекурсивный спуск и анализ приоритета. Я предполагаю, что то же самое применимо к Java и C #.
Между прочим, аналогичные проблемы с контекстной чувствительностью при синтаксическом анализе C ++ создали много неприятностей. « Альтернативный синтаксис функции » для C ++ 0x работает с аналогичной проблемой, перемещая спецификацию типа в конец и помещая ее после разделителя - очень похоже на двоеточие Паскаля для типов, возвращаемых функцией. Это не избавляет от чувствительности к контексту, но принятие этого паскалевского соглашения делает его немного более управляемым.
- в основном отмена добавлений к таблице символов, когда спекулятивный синтаксический анализ оказывается неправильным.На практике синтаксические анализаторы C и C ++ обычно написаны вручную, смешивая рекурсивный спуск и анализ приоритета. Я предполагаю, что то же самое применимо к Java и C #.
Между прочим, аналогичные проблемы с контекстной чувствительностью при синтаксическом анализе C ++ создали много неприятностей. « Альтернативный синтаксис функции » для C ++ 0x работает с аналогичной проблемой, перемещая спецификацию типа в конец и помещая ее после разделителя - очень похоже на двоеточие Паскаля для типов, возвращаемых функцией. Это не избавляет от чувствительности к контексту, но принятие этого паскалевского соглашения делает его немного более управляемым.
- в основном отмена добавлений к таблице символов, когда спекулятивный синтаксический анализ оказывается неправильным.На практике синтаксические анализаторы C и C ++ обычно пишутся от руки, смешивая рекурсивный спуск и анализ приоритета. Я предполагаю, что то же самое применимо к Java и C #.
Между прочим, аналогичные проблемы с контекстной чувствительностью при синтаксическом анализе C ++ создали много неприятностей. « Альтернативный синтаксис функции » для C ++ 0x работает с аналогичной проблемой, перемещая спецификацию типа в конец и помещая ее после разделителя - очень похоже на двоеточие Паскаля для типов, возвращаемых функцией. Это не избавляет от чувствительности к контексту, но принятие этого паскалевского соглашения делает его немного более управляемым.
Синтаксические анализаторы C и C ++ обычно пишутся вручную, смешивая рекурсивный спуск и синтаксический анализ приоритета. Я предполагаю, что то же самое применимо к Java и C #.Между прочим, аналогичные проблемы с контекстной чувствительностью при синтаксическом анализе C ++ создали множество неприятностей. « Альтернативный синтаксис функции » для C ++ 0x работает для решения аналогичной проблемы, перемещая спецификацию типа в конец и помещая ее после разделителя - очень похоже на двоеточие Паскаля для типов, возвращаемых функцией. Это не избавляет от чувствительности к контексту, но принятие этого паскалевского соглашения делает его немного более управляемым.
Синтаксические анализаторы C и C ++ обычно пишутся вручную, смешивая рекурсивный спуск и синтаксический анализ приоритета. Я предполагаю, что то же самое применимо к Java и C #.Между прочим, аналогичные проблемы с контекстной чувствительностью при синтаксическом анализе C ++ создали множество неприятностей. « Альтернативный синтаксис функции » для C ++ 0x работает с аналогичной проблемой, перемещая спецификацию типа в конец и помещая ее после разделителя - очень похоже на двоеточие Паскаля для типов, возвращаемых функцией. Это не избавляет от чувствительности к контексту, но принятие этого соглашения, подобного Pascal, делает его немного более управляемым.
«большинство других» языков, о которых вы говорите, являются более декларативными. Они нацелены на то, чтобы позволить вам программировать больше в соответствии с тем, что вы думаете (при условии, что вы не ограничены императивным мышлением).
type last читается как «создать переменную с именем NAME типа TYPE»
, это противоположное конечно, чтобы сказать «создать ТИП с именем ИМЯ», но когда вы думаете об этом, то, для чего это значение, более важно, чем тип, тип - это просто программное ограничение на данные
Растущая тенденция состоит в том, чтобы не указывать тип вообще или, при необходимости, указывать тип. Это может быть язык с динамической типизацией, где действительно нет типа для переменной, или язык со статической типизацией, который выводит тип из контекста.
Если тип иногда задается, а иногда является логическим, то проще прочтите, если после этого появится необязательный бит.
Существуют также тенденции, связанные с тем, считает ли язык себя исходящим из школы Си, функциональной школы или чего-то еще, но это пустая трата времени. Языки, которые улучшают своих предшественников и заслуживают изучения, - это те языки, которые готовы принимать предложения всех разных школ на основе заслуг, а не придирчиво относиться к наследию функции.
Если имя переменной начинается с столбца 0, легче найти имя переменной.
Сравните
QHash<QString, QPair<int, QString> > hash;
и
hash : QHash<QString, QPair<int, QString> >;
А теперь представьте, насколько читабельнее ваш типичный Заголовок C ++ может быть.
В формальной теории языков и теории типов это почти всегда записывается как var: type . Например, в типизированном лямбда-исчислении вы увидите доказательства, содержащие такие утверждения, как:
x : A y : B
-------------
\x.y : A->B
Я не думаю, что это действительно имеет значение, но я думаю, что есть два оправдания: первое состоит в том, что «x: A» читается как «x» относится к типу A ", другое - то, что тип подобен множеству (например, int - это набор целых чисел), и обозначение связано с" x ε A ".
Некоторые из этого материал предшествует современным языкам, о которых вы думаете.
Язык так и был разработан. Visual Basic всегда был таким.
Большинство (если не все) языков с фигурными скобками ставят тип на первое место. Для меня это более интуитивно понятно, поскольку в той же позиции также указывается тип возвращаемого значения метода. Таким образом, входные данные заключаются в круглые скобки, а выходные данные идут в конце имени метода.
Помещение типа в первую очередь помогает при синтаксическом анализе. Например, в C, если вы объявили переменные типа
x int;
. Когда вы анализируете только x , вы не знаете, является ли x объявлением или выражением. Напротив, с
int x;
Когда вы анализируете int , вы знаете, что находитесь в объявлении (типы всегда начинают какое-то объявление).
Учитывая прогресс в синтаксическом анализе языков, эта небольшая помощь в наши дни не особо полезен.
Фортран ставит тип первым:
REAL*4 I,J,K
INTEGER*4 A,B,C
И да, есть ( очень слабая) шутка для тех, кто знаком с Фортраном.
Есть основания утверждать, что это проще, чем C, который помещает информацию о типе вокруг имени, когда тип достаточно сложный (например, указатели на функции).
Я не уверен, но думаю, что это связано с концепцией «имя против существительного».
По сути, если вы сначала поместите тип (например, «int varname» "), вы объявляете" целое число с именем 'varname' "; то есть вы даете экземпляру типа имя. Однако, если вы сначала укажете имя, а затем тип (например, «varname: int»), вы скажете «это 'varname'; это целое число». В первом случае вы даете экземпляру чего-либо имя; во втором вы определяете существительное и заявляете, что оно является экземпляром чего-то.
Это немного похоже на определение стола как предмета мебели; сказать «это мебель, и я называю это« столом »» (напечатайте сначала) отличается от слова «
А как насчет динамически (приветствует @wcoenen) языков с типизацией? Вы просто используете переменную.
Мне всегда казалось, что способ, которым C это делает, несколько необычен: вместо того, чтобы создавать типы, пользователь должен объявить их неявно. Это не просто до / после имени переменной; в общем, вам может потребоваться встроить имя переменной среди атрибутов типа (или, в некоторых случаях, вставить пустое пространство, где имя было бы , если бы вы действительно его объявляли).
Как слабая форма сопоставления с образцом, она до некоторой степени понятна, но также не дает никаких особых преимуществ. А попытка записать (или прочитать) тип указателя на функцию может легко вывести вас за рамки понятности. Так что в целом этот аспект C является недостатком, и я рад видеть, что Go оставил его позади.