Время выполнения против времени компиляции

В чем разница между временем выполнения и временем компиляции?

Разница между временем компиляции и временем выполнения является примером того, что теоретики с острыми головами называют фазовым различием . Это одна из самых сложных концепций для изучения, особенно для людей, не имеющих большого опыта работы с языками программирования. Чтобы подойти к этой проблеме, я считаю полезным спросить

1. Какие инварианты программа удовлетворяет?
2. Что может пойти не так на этом этапе?
3. Если фаза успешна, каковы постусловия (что мы знаем)?
4. Каковы входы и выходы, если таковые имеются?

Время компиляции

1. Программа не должна удовлетворять никаким инвариантам. На самом деле, это не обязательно должна быть правильно сформированная программа. Вы можете передать этот HTML-код компилятору и посмотреть его ...
2. Что может пойти не так во время компиляции:
   • Синтаксические ошибки
   • Ошибки проверки типов
   • (Редко) вылетает компилятор
3. Если компилятор преуспевает, что мы знаем?
   • Программа была хорошо сформирована - значимая программа на любом языке.
   • Можно запустить программу. (Программа может сразу выйти из строя, но, по крайней мере, мы можем попробовать.)
4. Какие входы и выходы?
   • На вход была скомпилированная программа, а также любые заголовочные файлы, интерфейсы, библиотеки или другие файлы вуду, которые нужно было импортировать для компиляции.
   • Мы надеемся, что вывод - это ассемблерный код, перемещаемый объектный код или даже исполняемая программа. Или, если что-то пойдет не так, выводит кучу сообщений об ошибках.

Время выполнения

1. Мы ничего не знаем об инвариантах программы - они являются тем, что вставил программист. Инварианты времени выполнения редко применяются одним только компилятором; это нуждается в помощи от программиста.

2. Что может пойти не так, это ошибки времени выполнения :

   • Деление на ноль
   • Разыменование нулевого указателя
   • Недостаточно памяти

   Также могут быть ошибки, которые обнаруживает сама программа:

   • Попытка открыть файл, которого там нет
   • Попытка найти веб-страницу и обнаружить, что предполагаемый URL-адрес неправильно сформирован
3. Если время выполнения завершается успешно, программа завершает работу (или продолжает работать) без сбоев.
4. Входы и выходы полностью зависят от программиста. Файлы, окна на экране, сетевые пакеты, задания, отправленные на принтер, назовите его. Если программа запускает ракеты, это вывод, и это происходит только во время выполнения :-)

Я думаю об этом с точки зрения ошибок, и когда они могут быть обнаружены.

Время компиляции:

string my_value = Console.ReadLine();
int i = my_value;

Строковому значению нельзя присвоить переменную типа int, поэтому компилятор точно знает, у этого кода есть проблема

Время выполнения:

string my_value = Console.ReadLine();
int i = int.Parse(my_value);

Здесь результат зависит от того, какая строка была возвращена ReadLine (). Некоторые значения могут быть проанализированы в int, другие не могут. Это можно определить только во время выполнения

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

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

Вам нужно более четкое определение?

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

Например, следующая ошибка будет обнаружена компилятором (во время компиляции ) перед запуском программы и приведет к ошибке компиляции:

int i = "string"; --> error at compile-time

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

Hashtable ht = new Hashtable();
ht.Add("key", "string");
// the compiler does not know what is stored in the hashtable
// under the key "key"
int i = (int)ht["key"];  // --> exception at run-time

Преобразование исходного кода в вещи, происходящие на экране [screen | disk | network], может происходить (примерно) двумя способами; называть их составлением и интерпретацией.

В скомпилированной программе (примеры c и fortran):

1. Исходный код подается в другую программу (обычно называемую компилятором), которая создает исполняемую программу (или ошибку).
2. Исполняемый файл запускается (дважды щелкнув по нему или введя его имя в командной строке)

Говорят, что то, что происходит на первом этапе, происходит во «время компиляции», а то, что происходит на втором этапе, происходит во «время выполнения».

В интерпретируемой программе (например, MicroSoft Basic (на DOS) и Python (я думаю)):

1. Исходный код подается в другую программу (обычно называемую интерпретатором), которая «запускает» его напрямую. Здесь интерпретатор служит промежуточным слоем между вашей программой и операционной системой (или аппаратным обеспечением в действительно простых компьютерах).

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

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

Существует также промежуточный случай, когда программа компилируется в байт-код и запускается немедленно (как в awk или perl).

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

Например.

Постоянное складывание:

Если я напишу:

int i = 2;
i += MY_CONSTANT;

Компилятор может выполнить это вычисление во время компиляции, потому что он знает, что такое 2 и что такое MY_CONSTANT. Как таковой он избавляет себя от выполнения вычислений при каждом отдельном выполнении.

Хм, ладно, время выполнения используется для описания того, что происходит во время работы программы.

Время компиляции используется для описания того, что происходит при сборке программы (обычно компилятором).

Время компиляции:

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

Run-Time:

Более или менее полная противоположность. Меньше затрат при сборке, больше затрат при запуске программы.

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

Актуальность

Примером того, где это важно, был бы тип, несущий единицу. Версия во время компиляции (например, Boost.Units или моя версия в D ) оказывается такой же быстрой, как решение проблемы с собственным кодом с плавающей запятой, в то время как версия времени выполнения вынуждена собирать информацию о единицах измерения, в которых находятся значения. и выполнять проверки в них вдоль каждой операции. С другой стороны, версии времени компиляции требуют, чтобы единицы значений были известны во время компиляции, и не могут иметь дело со случаем, когда они поступают из ввода во время выполнения.

Исходя из предыдущего аналогичного ответа на вопрос В чем разница между ошибкой во время выполнения и ошибкой компилятора?

Ошибки компиляции / времени компиляции / синтаксиса / семантики: ошибки компиляции или времени компиляции - это ошибка, произошедшая из-за ошибки при вводе, если мы не соблюдаем правильный синтаксис и семантику любого языка программирования, то ошибки времени компиляции генерируются компилятором. Они не позволят вашей программе выполнить одну строку, пока вы не удалите все синтаксические ошибки или пока вы не отладите ошибки времени компиляции.
Пример: пропущена точка с запятой в C или опечатка intкак Int.

Ошибки времени выполнения: ошибки времени выполнения - это ошибки, которые генерируются, когда программа находится в рабочем состоянии. Эти типы ошибок приведут к непредсказуемому поведению вашей программы или даже к ее уничтожению. Их часто называют исключениями.
Пример. Предположим, вы читаете несуществующий файл, что приведет к ошибке во время выполнения.

Узнайте больше обо всех ошибках программирования здесь

В качестве дополнения к другим ответам, вот как я объясню это неспециалисту:

Ваш исходный код похож на план корабля. Это определяет, как корабль должен быть сделан.

Если вы передадите свой проект на верфь и обнаружите дефект при строительстве корабля, они прекратят его строительство и немедленно сообщат вам об этом, прежде чем корабль покинет сухой док или коснется воды. Это ошибка во время компиляции. Корабль даже не плавал и не использовал свои двигатели. Ошибка была найдена, потому что это препятствовало тому, чтобы судно было даже сделано.

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

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

Просто разница слов ч / б время компиляции и время выполнения.

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

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

Вот цитата Даниэля Ляна, автора «Введение в программирование на JAVA», на тему компиляции:

«Программа, написанная на языке высокого уровня, называется исходной программой или исходным кодом. Поскольку компьютер не может выполнить исходную программу, исходная программа должна быть переведена в машинный код для выполнения . Перевод может быть выполнен с использованием другого инструмента программирования, называемого интерпретатор или компилятор . " (Даниэль Лян, «Введение в программирование на JAVA» , стр. 8).

...Он продолжает...

«Компилятор переводит весь исходный код в файл машинного кода , а затем исполняется файл машинного кода»

Когда мы набираем код высокого уровня, понятный человеку, это, во-первых, бесполезно! Это должно быть переведено в последовательность «электронных событий» в вашем крошечном процессоре! Первый шаг к этому - компиляция.

Проще говоря: ошибка во время компиляции происходит во время этой фазы, а ошибка во время выполнения возникает позже.

Помните: только то, что программа скомпилирована без ошибок, не означает, что она будет работать без ошибок.

Ошибка времени выполнения будет возникать в части готовности, выполнения или ожидания в жизненном цикле программ, в то время как ошибка времени компиляции будет возникать до этапа «Новый» жизненного цикла.

Пример ошибки времени компиляции:

Синтаксическая ошибка - как ваш код может быть скомпилирован в инструкции машинного уровня, если они неоднозначны? Ваш код должен полностью соответствовать синтаксическим правилам языка, иначе он не может быть скомпилирован в работающий машинный код .

Пример ошибки во время выполнения:

Недостаточно памяти - например, вызов рекурсивной функции может привести к переполнению стека при заданной переменной определенной степени! Как это может ожидать компилятор !? оно не может.

И это разница между ошибкой во время компиляции и ошибкой во время выполнения

Время выполнения означает, что что-то происходит при запуске программы.

Время компиляции означает, что что-то происходит при компиляции программы.

Время компиляции:

Вещи, которые выполняются во время компиляции, не вызывают (почти) никаких затрат при запуске результирующей программы, но могут повлечь за собой большие затраты при сборке программы. Run-Time:

Более или менее полная противоположность. Меньше затрат при сборке, больше затрат при запуске программы.

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

Время компиляции: Время, необходимое для преобразования исходного кода в машинный код, чтобы он стал исполняемым, называется временем компиляции.

Время выполнения: когда приложение работает, оно называется временем выполнения.

Ошибки времени компиляции - это те синтаксические ошибки, отсутствующие ошибки ссылки на файл. Ошибки во время выполнения происходят после того, как исходный код был скомпилирован в исполняемую программу и во время работы программы. Примерами являются сбои программы, непредвиденное поведение программы или функции не работают.

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

Вот расширение к ответу на вопрос "разница между временем выполнения и временем компиляции?" - Различия в накладных расходах, связанных со временем выполнения и временем компиляции?

Производительность продукта во время выполнения повышает его качество за счет более быстрого предоставления результатов. Производительность продукта во время компиляции способствует его своевременности, сокращая цикл edit-compile-debug. Однако как производительность во время выполнения, так и производительность во время компиляции являются вторичными факторами в достижении своевременного качества. Следовательно, следует учитывать улучшения производительности во время выполнения и во время компиляции, только если это оправдано улучшением общего качества и своевременности продукта.

Отличный источник для дальнейшего чтения здесь :

Я всегда думал об этом как о накладных расходах на обработку программ и о том, как это влияет на предварительную производительность, как было сказано ранее. Простым примером будет либо определение абсолютной памяти, необходимой для моего объекта в коде, либо нет.

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

С другой стороны, если я просто определяю общий тип объекта (т. Е. Вид неопределенного заполнителя или, возможно, указатель на какой-то гигантский BLOB-объект), фактическая память, необходимая для моего объекта, неизвестна до тех пор, пока программа не будет запущена, и я не назначу ей что-либо таким образом, он затем должен быть оценен, а распределение памяти и т. д. будет динамически обрабатываться во время выполнения (больше накладных расходов во время выполнения).

То, как он обрабатывается динамически, зависит от языка, компилятора, ОС, вашего кода и т. Д.

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

мы можем классифицировать их по двум различным группам: статическое и динамическое. Он основан на том, когда привязка выполняется с соответствующими значениями. Если ссылки разрешаются во время компиляции, то это статическая привязка, а если ссылки разрешаются во время выполнения, то это динамическая привязка. Статическое связывание и динамическое связывание также называют ранним связыванием и поздним связыванием. Иногда их также называют статическим полиморфизмом и динамическим полиморфизмом.

Джозеф Куландай.

Основное различие между временем выполнения и временем компиляции:

1. Если в вашем коде есть какие-либо синтаксические ошибки и проверки типов, то он выдает ошибку времени компиляции, где-как время выполнения: он проверяет после выполнения кода. Например:

int a = 1 int b = a/0;

здесь первая строка не имеет точку с запятой в конце ---> ошибка времени компиляции после выполнения программы во время выполнения операции b, результат бесконечный ---> ошибка времени выполнения.

2. Время компиляции не ищет вывод функциональности, предоставляемой вашим кодом, в то время как время выполнения делает.

вот очень простой ответ:

Время выполнения и время компиляции - это термины программирования, которые относятся к различным этапам разработки программного обеспечения. Чтобы создать программу, разработчик сначала пишет исходный код, который определяет, как программа будет функционировать. Небольшие программы могут содержать только несколько сотен строк исходного кода, в то время как большие программы могут содержать сотни тысяч строк исходного кода. Исходный код должен быть скомпилирован в машинный код, чтобы стать и исполняемой программой. Этот процесс компиляции называется временем компиляции (думайте о компиляторе как о трансляторе)

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

Термины «время выполнения» и «время компиляции» часто используются программистами для обозначения различных типов ошибок. Ошибка времени компиляции - это проблема, такая как синтаксическая ошибка или отсутствующая ссылка на файл, которая препятствует успешной компиляции программы. Компилятор выдает ошибки времени компиляции и обычно указывает, какая строка исходного кода вызывает проблему.

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

Ссылка

ИМХО, вам нужно прочитать много ссылок, ресурсов, чтобы составить представление о разнице между временем выполнения и временем компиляции, потому что это очень сложная тема. У меня есть список ниже некоторых из этих фотографий / ссылок, которые я рекомендую.

Помимо сказанного выше, хочу добавить, что иногда картинка стоит 1000 слов:

1. порядок этих двух: сначала время компиляции, а затем вы запускаете. Скомпилированная программа может быть открыта и запущена пользователем. Когда приложение работает, оно называется временем выполнения: время компиляции, а затем время выполнения1 ;

CLR_diag время компиляции и затем runtime2

 from Wiki  

https://en.wikipedia.org/wiki/Run_time https://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)

Время выполнения, время выполнения или время выполнения может относиться к:

Вычислительный

Время выполнения (фаза жизненного цикла программы) , период, в течение которого выполняется компьютерная программа

Runtime library , библиотека программ, предназначенная для реализации функций, встроенных в язык программирования

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

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

Список компиляторов https://en.wikipedia.org/wiki/List_of_compilers

• поиск в Google и сравнение ошибок времени выполнения и ошибок компиляции:

;

3. На мой взгляд, очень важная вещь: 3.1. Разница между сборкой и компиляцией и жизненным циклом сборки https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

3.2 разница между этими 3 вещами: компиляция против сборки против времени выполнения

https://www.quora.com/What-is-the-difference-between-build-run-and-compile Фернандо Падоан, разработчик, которому немного любопытно на языковой дизайн Ответил 23 февраля Я возвращаюсь в отношениях на другие ответы:

Выполнение - это получение некоторого двоичного исполняемого файла (или сценария для интерпретируемых языков), который, хорошо… выполняется как новый процесс на компьютере; Компиляция - это процесс синтаксического анализа программы, написанной на каком-либо языке высокого уровня (более высокого по сравнению с машинным кодом), проверки ее синтаксиса, семантики, связывания библиотек, возможно, выполнения некоторой оптимизации, а затем создания двоичной исполняемой программы в качестве вывода. Этот исполняемый файл может быть в форме машинного кода или какого-то байт-кода, то есть инструкций, ориентированных на какую-то виртуальную машину; Сборка обычно включает в себя проверку и предоставление зависимостей, проверку кода, компиляцию кода в двоичный файл, запуск автоматических тестов и упаковку полученных двоичных файлов и других ресурсов (изображений, файлов конфигурации, библиотек и т. д.) в некоторый определенный формат развертываемого файла. Обратите внимание, что большинство процессов являются необязательными, а некоторые зависят от целевой платформы, для которой вы строите. В качестве примера, упаковка Java-приложения для Tomcat выведет файл .war. Сборка исполняемого файла Win32 из кода C ++ может просто выводить программу .exe или упаковывать ее в установщик MSI.

Посмотрите на этот пример:

public class Test {

    public static void main(String[] args) {
        int[] x=new int[-5];//compile time no error
        System.out.println(x.length);
    }}

Приведенный выше код успешно скомпилирован, синтаксической ошибки нет, он совершенно корректен. Но во время выполнения выдает следующую ошибку.

Exception in thread "main" java.lang.NegativeArraySizeException
    at Test.main(Test.java:5)

Например, когда во время компиляции проверяются определенные случаи, после этого времени выполнения проверяются определенные случаи, когда программа удовлетворяет всем условиям, которые вы получите на выходе. В противном случае вы получите ошибку времени компиляции или выполнения.

открытый класс RuntimeVsCompileTime {

public static void main(String[] args) {

    //test(new D()); COMPILETIME ERROR
    /**
     * Compiler knows that B is not an instance of A
     */
    test(new B());
}

/**
 * compiler has no hint whether the actual type is A, B or C
 * C c = (C)a; will be checked during runtime
 * @param a
 */
public static void test(A a) {
    C c = (C)a;//RUNTIME ERROR
}

}

class A{

}

class B extends A{

}

class C extends A{

}

class D{

}

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

Это не очень хороший вопрос для SO (это не конкретный вопрос программирования), но в целом это неплохой вопрос.

Если вы думаете, что это тривиально: как насчет времени чтения и времени компиляции, и когда это полезное различие? А как насчет языков, где компилятор доступен во время выполнения? Гай Стил (не тупой, он) написал 7 страниц в CLTL2 о EVAL-WHEN, которые программисты CL могут использовать для управления этим. 2 предложения едва хватает для определения , которое само по себе далеко от объяснения .

В общем, это сложная проблема, которую разработчики языка, похоже, пытались избежать. Они часто просто говорят: «Вот компилятор, он делает вещи во время компиляции; все, что после этого - время выполнения, получайте удовольствие». C разработан, чтобы быть простым в реализации, а не самой гибкой средой для вычислений. Если у вас нет компилятора, доступного во время выполнения, или у вас нет возможности легко управлять оценкой выражения, вы, как правило, в конечном итоге получаете хаки на языке, чтобы имитировать обычное использование макросов, или пользователи придумывают шаблоны проектирования для имитации имея более мощные конструкции. Простой в реализации язык, безусловно, может быть достойной целью, но это не значит, что это все-таки все-таки все в разработке языка программирования. (Я редко использую EVAL-WHEN, но я не могу представить свою жизнь без него.)

И проблемное пространство вокруг времени компиляции и выполнения огромно и все еще в значительной степени не изучено. Это не значит, что SO является подходящим местом для обсуждения, но я призываю людей исследовать эту территорию дальше, особенно тех, у кого нет предвзятых представлений о том, что это должно быть. Вопрос не простой и не глупый, и мы могли бы, по крайней мере, указать инквизитору в правильном направлении.

К сожалению, я не знаю хороших ссылок на это. CLTL2 немного говорит об этом, но это не очень хорошо для изучения.