Какой компилятор использует visual studio

Microsoft Visual C++

Microsoft Visual C++ (сокр. MSVC) — программа-компилятор для языков программирования C, C++, C++/CLI и C++/CX от компании Microsoft, представляющая собой набор библиотек и средств разработки на языках ассемблера, C++ и C, которые входят в состав Visual Studio в Windows [1] .

Библиотека Microsoft Visual C++

Иконка Visual Studio

В программу Visual Studio входят так называемые «стандартные библиотеки». Это наборы предварительно написанного программного обеспечения, позволяющие программистам избежать переписывания общих последовательностей кода. Программисты для улучшения качества кода и ускорения программирования используют эту коллекцию (стандартные библиотеки) предварительно написанного и тщательно протестированного программного обеспечения [2] .

MSVC — это программное обеспечение компании Microsoft, первоначально отдельный продукт, позднее — часть Visual Studio, доступный как в пробной, так и в бесплатной форме. Он содержит инструменты для разработки и отладки кода C++, особенно кода, написанного для Windows API, DirectX и .NET.

Распространяемый компонент Visual C++ устанавливает библиотеки среды выполнения Microsoft C и C++ (MSVC). Эти библиотеки необходимы для многих приложений, созданных с помощью средств Microsoft C и C++. Если приложение использует эти библиотеки, перед установкой приложения в целевой системе необходимо установить пакет распространяемого Microsoft Visual C++. Архитектура распространяемого пакета должна соответствовать целевой архитектуре приложения. Версия распространяемого компонента должна быть по крайней мере той же, что и набор инструментов сборки MSVC, используемый для сборки приложения.

Visual Studio

Microsoft Visual C++ (MSVC) является частью комплекта Microsoft Visual Studio.

Visual Studio — это среда программирования (IDE) для языка C++ и других, самая популярная IDE для программирования на С++.

Средства и библиотеки MSVC позволяют создавать собственные классические и серверные приложения Windows, приложения универсальной платформы Windows (UWP) или управляемые приложения и библиотеки, использующие платформу .NET Framework. Доступно создание кроссплатформенных библиотек и приложений, работающих в Windows, Linux, Android и iOS. С помощью MSVC можно создавать любые сложные приложения из простых консольных приложений для компьютеров с Windows [3] .

Примечания

↑TylerMSFT, Taojunshen, corob-msft, DCtheGeek, john-par, mikeblome.C и C++ в Visual Studio(неопр.) . https://www.microsoft.com/ (2023.04.03). Дата обращения: 2023.05.26.
↑Leo A. Notenboom.Do I Need All These Microsoft Visual C++ Redistributables?(англ.). https://askleo.com/ (2020.09.07). Дата обращения: 2023.05.26.
↑Разработка приложений на C и C++(неопр.) . https://www.microsoft.com/. Дата обращения: 2023.05.26.

Данная статья имеет статус «готовой». Это не говорит о качестве статьи, однако в ней уже в достаточной степени раскрыта основная тема. Если вы хотите улучшить статью — правьте смело!

Знание.Вики:Cite web (не указан язык)
Технологии
Все статьи
Программное обеспечение Microsoft
Программное обеспечение
Языки программирования

Где находится C# компилятор последней версии?

Ребят, я тут хочу с помощью команды Console.WriteLine() вывести слово вместе с интерполяции строки. О чём я имею виду:

Using System; class Program < static void Main(string[] args) < string name = "Artem"; Console.WriteLine($"Hello, !"); > >

Всё работает если запустить проект через Microsoft Visual Studio. Также нормально компилирует Developer Prompt. Но путь компилятора:

C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe

пишет: Не предвиденный символ «$» Какой компилятор использует Visual Studio и Developer Prompt, и где находится этот компилятор, скажите пж! Мой

Microsoft Visual Studio 2019 Enterprise

P.s.: не пишите что нужен C# компилятор 6.0 или 5.0, я знаю. И также не пишите про путь

C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe

Спасибо! Мой полный код

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApp2 < class Program < static void Main(string[] args) < string name = "Artem"; Console.WriteLine($"Hello, !"); Console.ReadKey(); > > >

Отслеживать
задан 10 мая 2020 в 6:13
94 1 1 серебряный знак 9 9 бронзовых знаков
Комментарии не предназначены для расширенной дискуссии; разговор перемещён в чат.
10 мая 2020 в 12:12

3 ответа 3

Сортировка: Сброс на вариант по умолчанию

Не уверен, что все еще актуально для автора, но корректный ответ все же нужен.

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

Для того чтобы указать конкретную версию синтаксиса компилятору, используется специальный ключ для консольного компилятора csc.exe: -langversion. В документации есть полный список доступных на данный момент версий синтаксиса, который также можно получить во встроенной справке самого компилятора по ключу /? или -?.

Учтите, что в стандартной поставке .NET Framework, компилятор умеет работать только с версиями синтаксиса C# до 5.0 включительно, для поддержки более новых версий, которые еще не стандартизованы, нужно будет более детально ознакомиться с документацией и добавить все необходимое, например компилятор Roslyn, или перейти с .NET Framework на .NET Core, возможно есть и другие варианты, глубоко не копал.

Либо оформить код в виде проекта, в нем указать версию синтаксиса и воспользоваться утилитой MSBuild.exe, которая также входит как в стандартную поставку .NET Framework (с большой вероятностью будет использовать компилятор из стандартной поставки), так и может быть установлена вместе с MS VisualStudio или пакетом SDK (будет использовать более актуальную версию из пакета SDK), может быть запущена из консоли и выполнит все необходимое в автоматическом режиме. Ей потребуется, в простейшем случае, только указать что собирать и куда складывать. Вариант с MSBuild мне кажется более простым, понятным, а потому более предпочтительным. Ну если конечно вашей целью не является изучение редко используемых возможностей компилятора, вроде модульных сборок и т.п.

Инструменты сборки#

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

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

Прежде всего, ваша интегрированная среда разработки (IDE), возможно, предоставляет способ сборки вашей программы. Популярным кроссплатформенным инструментом является Visual Studio Code от Microsoft, но существуют и другие, такие как Atom, Eclipse Photran, и Code::Blocks. Они предлагают пользовательский интерфейс, но часто очень специфичны для компилятора и платформы.

Для небольших проектов часто используется система сборки make . На основе заданных правил она может выполнять такие задачи, как (пере)компиляция объектных файлов из обновлённых файлов исходных кодов, создание библиотек, и компоновка исполняемых файлов. Чтобы использовать make , для вашего проекта вы должны создать эти правила в файле Makefile , который определяет взаимозависимости всех конечных программ, промежуточных объектных файлов или библиотек и непосредственно файлов исходных кодов. Краткое введение по этой системе сборки приводится в руководстве по make .

Инструменты сопровождения, такие как autotools и CMake, могут генерировать файлы Makefile или файлы проектов Visual Studio через высокоуровневое описание. Они абстрагируются от специфики компилятора и платформы.

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

Также обратите внимание на доступность инструментов сборки. Если их использование ограничено одной IDE, смогут ли все разработчики вашего проекта получить к ним доступ? Если вы используете определённую систему сборки, работает ли она на всех платформах, для которых вы разрабатываете? Насколько велик входной порог для ваших инструментов сборки? Предварительно узнайте о кривой обучения для инструментов сборки – идеальный инструмент сборки будет бесполезен, если сначала вам сначала придётся изучить сложный язык программирования, чтобы добавить новый файл исходного кода. Наконец, посмотрите, какие другие проекты вы используете как зависимости и какие используют (или будут использовать) ваш проект как зависимость.

Использование make как инструмент сборки#

Наиболее известная и часто используемая система сборки называется make . Она выполняет действия, следуя правилам, определенным в конфигурационном файле, называемом Makefile или makefile , что обычно приводит к компиляции программы из предоставленного исходного кода.

Для ознакомления с подробным руководством по make смотрите его информационную страницу. Существует онлайн версия этой информационной страницы, доступная по ссылке.

Мы начнём с основ, находясь в пустом каталоге. Создайте и откройте файл с именем Makefile , в котором создайте простое правило под названием all:

all: echo "$@"

После сохранения файла Makefile запустите его, выполнив команду make в той же директории. Вы должны будете увидеть следующий вывод:

echo "all" all

Во-первых, заметим, что make подставляем вместо $@ имя правила; во-вторых, что следует отметить, make всегда выводит выполняемую команду; наконец, мы видим результат выполнения команды echo \»all\» .

Мы всегда называем точку входа нашего Makefile all по договорённости, но вы можете выбрать для неё любое другое имя, которое вам нравится.

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

Makefile:2: *** missing separator. Stop.

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

Теперь мы хотим усложнить наши правила, поэтому добавим ещё одно:

PROG := my_prog all: $(PROG) echo "$@ depends on $^" $(PROG): echo "$@"

Обратите внимание, как мы объявляем переменные в make : вы всегда должны объявлять свои локальные переменные с помощью оператора := . Для доступа к содержимому переменной используется оператор $(. ) . Заметьте, что при этом необходимо заключить имя переменной в круглые скобки.

Объявление переменных обычно выполняется с помощью оператора := , но make поддерживает и рекурсивно расширяемые переменные с помощью оператора = . Обычно желательно использовать первый тип объявления, так как такие переменные более предсказуемы и не имеют накладных расходов во время выполнения из-за рекурсивного расширения.

Мы добавили зависимость для правила all, а именно содержимое переменной PROG . Также мы изменили вывод, чтобы видеть все зависимости этого правила, которые хранятся в переменной $^ . Теперь для нового правила, которое мы назвали по значению переменной PROG , выполняются те же операции, что были выполнены выше для правила all. Обратите внимание, как значение переменной $@ зависит от правила, в котором она используется.

Выполнив команду make снова, теперь вы должны увидеть:

echo "my_prog" my_prog echo "all depends on my_prog" all depends on my_prog

Зависимость была правильно разрешена и вычислена перед выполнением любого действия в правиле all. Давайте запустим выполнение только второго правила: наберите команду make my_prog и в вашем терминале отобразятся только первые две строки предыдущего вывода.

Следующим шагом будет выполнение некоторых реальных действий с помощью make , мы возьмем исходный код из предыдущей главы и добавим новые правила в наш Makefile :

OBJS := tabulate.o functions.o PROG := my_prog all: $(PROG) $(PROG): $(OBJS) gfortran -o $@ $^ $(OBJS): %.o: %.f90 gfortran -c -o $@ $

Мы определили переменную OBJS , содержащую список объектных файлов. Наша программа зависит от списка OBJS и для каждого элемента из него мы создаём правило, чтобы скомпилировать объектный файл из файла исходного кода. Последнее правило, которое мы описали является правилом сопоставления шаблонов, где % – общий шаблон между tabulate.o и tabulate.f90 , который соединяет наш объектный файл tabulate.o с файлом исходного кода tabulate.f90 . Используя этот набор, мы запускаем компилятор gfortran и транслируем исходный код в объектный файл, при этом исполняемый файл пока не создаётся, так как используется ключ компилятора -c . Обратите внимание на использование переменной $< для обращения к первому элементу списка зависимостей.

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

Теперь мы запускаем сценарий сборки командой make :

gfortran -c -o tabulate.o tabulate.f90 tabulate.f90:2:7: 2 | use user_functions | 1 Fatal Error: Cannot open module file ‘user_functions.mod’ for reading at (1): No such file or directory compilation terminated. make: *** [Makefile:10: tabulate.f90.o] Error 1

Мы помним, что у нас есть зависимости между нашими исходными файлами, поэтому мы явно добавляем эту зависимость в Makefile с помощью правила

tabulate.o: functions.o

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

gfortran -c -o functions.o functions.f90 gfortran -c -o tabulate.o tabulate.f90 gfortran -o my_prog tabulate.o functions.o

В каталоге должны появиться четыре новых файла. Запустите программу my_prog , чтобы убедиться, что она работает как ожидается. Попробуйте выполнить команду make ещё раз:

make: Nothing to be done for 'all'.

Используя временные метки исполняемого файла make определил, что исполняемый файл новее чем каждый из файлов tabulate.o и functions.o , которые, в свою очередь, новее чем файлы исходного кода tabulate.f90 и functions.f90 . Поэтому программа уже соответствует содержимому файлов исходного кода и никаких действий по её пересборке выполнять не нужно.

В заключение мы рассмотрим готовый вариант скрипта Makefile .

# Disable all of make's built-in rules (similar to Fortran's implicit none) MAKEFLAGS += --no-builtin-rules --no-builtin-variables # configuration FC := gfortran LD := $(FC) RM := rm -f # list of all source files SRCS := tabulate.f90 functions.f90 PROG := my_prog OBJS := $(addsuffix .o, $(SRCS)) .PHONY: all clean all: $(PROG) $(PROG): $(OBJS) $(LD) -o $@ $^ $(OBJS): %.o: % $(FC) -c -o $@ $< # define dependencies between object files tabulate.f90.o: functions.f90.o user_functions.mod # rebuild all object files in case this Makefile changes $(OBJS): $(MAKEFILE_LIST) clean: $(RM) $(filter %.o, $(OBJS)) $(wildcard *.mod) $(PROG)

Поскольку вы начинаете с системы сборки make мы настоятельно рекомендуем всегда добавлять указанную первую строчку, так как и в случае с оператором Fortran implicit none , мы не хотим, чтобы неявные правила испортили наш Makefile неожиданным и вредным образом.

Далее идёт раздел конфигурации, где мы определяем переменные. В случае если вы захотите указать другой компилятор, это легко сделать здесь. Мы также ввели переменную SRCS для хранения списка всех файлов исходного кода, что более интуитивно понятно, чем указание списка объектных файлов. Мы можем легко создать список объектных файлов, добавив суффикс .o при помощи функции addsuffix . .PHONY – специальное правило, которое должно использоваться для всех точек входа вашего Makefile . В нём мы определяем две точки входа: уже известное нам правило all и новое правило clean, которое удаляет все файлы, полученные в процессе сборки программы, чтобы следующая сборка выполнялась с самого начала.

Также мы немного изменили правило сборки для объектных файлов, чтобы учесть добавление суффикса .o вместо замены на него. Обратите внимание, что нам по прежнему нужно явно определять взаимозависимости в Makefile . Мы также добавили зависимость для объектных файлов от самого Makefile , на случай если вы укажите другой компилятор. Это позволит вам безопасно выполнить пересборку.

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

В этом руководстве мы избегали использования и отключили многие часто используемые возможности make , которые могут быть особенно проблемными при неправильном применении. Мы настоятельно рекомендуем воздержаться от использования встроенных правил и переменных, если вы не чувствуете себя уверенно при работе с make , и использовать явное объявление переменных и правил.

Вы обнаружите, что make является удобным инструментом для автоматизации коротких взаимозависимых рабочих процессов и создания небольших проектов. Но для больших проектов вы, вероятно, вскоре столкнётесь с некоторыми его ограничениями. Поэтому обычно make используется не сам по себе, а в сочетании с другими инструментами для создания файла Makefile полностью или создания его фрагментов.

Рекурсивно расширяемые переменные#

Во многих проектах часто встречаются рекурсивно расширяемые переменные (объявление с использованием оператора = вместо := ). Рекурсивное расширение ваших переменных позволяет объявлять их не по порядку и делать другие хитрые трюки с использованием make , так как они определяются как правила, которые расширяются во время выполнения, а не во время анализа.

Например, объявление и использование ваших флагов компиляции Fortran с помощью приведённого ниже фрагмента будет работать совершенно нормально:

all: echo $(FFLAGS) FFLAGS = $(include_dirs) -O include_dirs += -I./include include_dirs += -I/opt/some_dep/include

После выполнения команды make вы должны получить ожидаемый (или, возможно, неожиданный) вывод

echo -I./include -I/opt/some_dep/include -O -I./include -I/opt/some_dep/include -O

добавление к списку с помощью оператора += для неинициализированной переменной приведёт к её рекурсивному расширению, причём это состояние будет наследоваться при всех дальнейших добавлениях.

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

Нужного эффекта при объявлении можно добиться используя оператор := :

all: echo $(FFLAGS) include_dirs := -I./include include_dirs += -I/opt/some_dep/include FFLAGS := $(include_dirs) -O

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

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

Комментарии и символ пробела#

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

Другая распространённая проблема – символы пробела в начале и конце строки. Если их ввести, то make воспримет их как часть строки и это повлияет на содержимое этих строк внутри файла make .

Такое может произойти при добавлении комментария

prefix := /usr # path to install location install: echo "$(prefix)/lib"

Хотя комментарий будет корректно удалён при анализе утилитой make , но два завершающих пробельных символа являются частью содержимого переменной. Запустите команду make и убедитесь, что это действительно так:

echo "/usr /lib" /usr /lib

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

prefix := /usr # path to install location install: echo "$(strip $(prefix))/lib" echo "$(join $(join $(prefix), /), lib)"

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

Система сборки meson#

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

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

Давайте посмотрим на готовый файл meson.build :

project('my_proj', 'fortran', meson_version: '>=0.49') executable('my_prog', files('tabulate.f90', 'functions.f90'))

И этого достаточно, следующим шагом будет настройка нашей низкоуровневой системы сборки с помощью команды meson setup build , в результате выполнения которой вы должны увидеть результат, похожий на этот

The Meson build system Version: 0.53.2 Source dir: /home/awvwgk/Examples Build dir: /home/awvwgk/Examples/build Build type: native build Project name: my_proj Project version: undefined Fortran compiler for the host machine: gfortran (gcc 9.2.1 "GNU Fortran (Arch Linux 9.2.1+20200130-2) 9.2.1 20200130") Fortran linker for the host machine: gfortran ld.bfd 2.34 Host machine cpu family: x86_64 Host machine cpu: x86_64 Build targets in project: 1 Found ninja-1.10.0 at /usr/bin/ninja

Представленная информация на данный момент уже более подробна, чем все, что мы могли бы описать в файле Makefile . Давайте запустим сборку с помощью команды ninja -C build , в результате выполнения которой отобразится что-то похожее на вывод

[1/4] Compiling Fortran object 'my_prog@exe/functions.f90.o'. [2/4] Dep hack [3/4] Compiling Fortran object 'my_prog@exe/tabulate.f90.o'. [4/4] Linking target my_prog.

Найдите и протестируйте свою программу в каталоге build/my_prog , чтобы убедиться, что она работает правильно. Заметим, что последовательность шагов, которую выполнила система сборки ninja , аналогична той, которую бы мы записали в Makefile (включая указание зависимости), но нам не пришлось её явно описывать. Посмотрите ещё раз на свой файл meson.build :

project('my_proj', 'fortran', meson_version: '>=0.49') executable('my_prog', files('tabulate.f90', 'functions.f90'))

Мы только указали, что у нас есть проект на языке Fortran (для поддержки проектов на языке Fortran требуется определенная версия meson ) и сказали системе сборки meson собрать исполняемый файл my_prog из файлов исходного кода tabulate.f90 и functions.f90 . Нам не нужно было указывать meson , как собирать проект, система сборки разобралась с этим сама.

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

Документация системы сборки meson доступна на веб-странице meson-build.

Создание проекта в системе сборки CMake#

Подобно meson , система сборки CMake является высокоуровневой и часто используется для сборки проектов на языке Fortran.

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

Начните с создания файла CMakeLists.txt со следующим содержимым

cmake_minimum_required(VERSION 3.7) project("my_proj" LANGUAGES "Fortran") add_executable("my_prog" "tabulate.f90" "functions.f90")

Как и в случае с meson , этого достаточно для сборки нашей программы с помощью файла сборки CMake. Мы настроим наши низкоуровневые файлы сборки с помощью команды cmake -B build -G Ninja , в результате выполнения которой вы увидите вывод, похожий на следующий

-- The Fortran compiler identification is GNU 10.2.0 -- Detecting Fortran compiler ABI info -- Detecting Fortran compiler ABI info - done -- Check for working Fortran compiler: /usr/bin/f95 - skipped -- Checking whether /usr/bin/f95 supports Fortran 90 -- Checking whether /usr/bin/f95 supports Fortran 90 - yes -- Configuring done -- Generating done -- Build files have been written to: /home/awvwgk/Examples/build

Вас может удивить, что CMake пытается использовать компилятор f95 . К счастью, в большинстве систем это имя символической ссылки на компилятор gfortran , а не непосредственно компилятор f95 . Чтобы подсказать CMake какой компилятор использовать, вы можете экспортировать переменную окружения FC=gfortran . Повторный вызов приведённый выше команды настройки должен отобразить правильное имя компилятора

-- The Fortran compiler identification is GNU 10.2.0 -- Detecting Fortran compiler ABI info -- Detecting Fortran compiler ABI info - done -- Check for working Fortran compiler: /usr/bin/gfortran - skipped -- Checking whether /usr/bin/gfortran supports Fortran 90 -- Checking whether /usr/bin/gfortran supports Fortran 90 - yes -- Configuring done -- Generating done -- Build files have been written to: /home/awvwgk/Example/build

Аналогичным образом вы можете использовать ваш компилятор Intel Fortran compiler для сборки вашего проекта (установив переменную окружения FC=ifort ).

CMake обеспечивает поддержку нескольких низкоуровневых файлов сборки, так как по умолчанию они зависят от используемой платформы. Мы будем применять только низкоуровневую систему сборки ninja , так как мы уже использовали её вместе с meson . Как и прежде, собрать проект при этом можно с помощью команды ninja -C build :

[1/6] Building Fortran preprocessed CMakeFiles/my_prog.dir/functions.f90-pp.f90 [2/6] Building Fortran preprocessed CMakeFiles/my_prog.dir/tabulate.f90-pp.f90 [3/6] Generating Fortran dyndep file CMakeFiles/my_prog.dir/Fortran.dd [4/6] Building Fortran object CMakeFiles/my_prog.dir/functions.f90.o [5/6] Building Fortran object CMakeFiles/my_prog.dir/tabulate.f90.o [6/6] Linking Fortran executable my_prog

Найдите и протестируйте свою программу в каталоге build/my_prog , чтобы убедиться, что она работает правильно. Последовательность шагов, выполняемая системой сборки ninja в этот раз несколько отличается, потому что существует более одного способа записи низкоуровневых файлов сборки для выполнения задачи сборки проекта. К счастью, нам не нужно беспокоиться об этом, а поручить нашей системе сборки учесть эти детали за нас.

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

cmake_minimum_required(VERSION 3.7) project("my_proj" LANGUAGES "Fortran") add_executable("my_prog" "tabulate.f90" "functions.f90")

Мы указали, что у нас есть проект на языке Fortran и сказали системе сборки CMake создать исполняемый файл my_prog на основе файлов исходного кода tabulate.f90 и functions.f90 . CMake знает, как собрать исполняемый файл из указанных исходных файлов, поэтому нам не нужно беспокоиться о фактически выполняемых шагах в процессе сборки.

CMake’s official reference can be found at the CMake webpage. It is organised in manpages, which are also available with your local CMake installation as well using man cmake . While it covers all functionality of CMake, it sometimes covers them only very briefly.

The SCons build system#

SCons is one another high-level cross-platform build system with automatic dependency analysis that supports Fortran projects. SCons configuration files are executed as Python scripts but it could be successfully used without knowledge about Python programming. The using of Python scripting if needed allows to handle build process and file naming in more sophisticated manner.

SCons doesn’t automatically passes the external environment variables such as PATH therefore it will not find programs and tools that installed into non-standard locations unless are specified or passed via appropriate variables. That guaranties that build isn’t affected by external (especially user’s) environment variables and build is repeatable. The most of such variables and compiler options and flags are required to be configured within special «isolated» Environments (please refer to User Guide for additional information).

The SCons doesn’t use external low-level build systems and relies on own build system. The ninja support as external tool to generate ninja.build file is highly experimental (available since scons 4.2) and required to be enabled explicitly by additional configuration.

The simple SCons project is SConstruct file that contains:

Program('my_proj', ['tabulate.f90', 'functions.f90'])

The next step is to build our project with command scons :

scons: Reading SConscript files . scons: done reading SConscript files. scons: Building targets . gfortran -o functions.o -c functions.f90 gfortran -o tabulate.o -c tabulate.f90 gfortran -o my_proj tabulate.o functions.o scons: done building targets.

or with scons -Q to disable extended output:

gfortran -o functions.o -c functions.f90 gfortran -o tabulate.o -c tabulate.f90 gfortran -o my_proj tabulate.o functions.o

Find and test your program my_prog at the same directory as source files (by default) to ensure it works correctly.

To cleanup the build artifacts run scons -c (or scons -Qc ):

scons: Reading SConscript files . scons: done reading SConscript files. scons: Cleaning targets . Removed functions.o Removed user_functions.mod Removed tabulate.o Removed my_proj scons: done cleaning targets.

In our SCons SConstruct file

Program('my_proj', ['tabulate.f90', 'functions.f90'])

we specified executable target name my_proj (optional, if omitted the first source file name is used) and list of source files ['tabulate.f90', 'functions.f90'] . There is no need to specify project source files language – it’s detected automatically by SCons for supported languages.

The list of source files could be specified with SCons Glob function:

Program('my_proj', Glob('*.f90'))

or using SCons Split function:

Program('my_proj', Split('tabulate.f90 functions.f90'))

or in more readable form by assigning variable:

src_files = Split('tabulate.f90 functions.f90') Program('my_proj', src_files)

In case of Split function the multiple lines could be used with Python «triple-quote» syntax:

src_files = Split("""tabulate.f90 functions.f90""") Program('my_proj', src_files)

SCons official webpage provides: User Guide with extended description of various aspects how to handle the build process, Frequently Asked Questions page and man page.

so the DOM is not blocked -->

Как запустить свою первую программу на Microsoft Visual C++ 6.0?

На сегодняшний день компилятор Microsoft Visual C++ 6.0 продолжает оставаться одним из самых популярных компиляторов С++! Несмотря на выход в свет более поздних версий, достаточно много программистов успели "прикипеть" именно к 6-й версии; за долгие годы было создано огромное количество проектов, написанных именно на VC++ 6.0 требующих обновления и сопровождения. Совместимость же этих проектов с более новыми выпусками VC++ хуже, чем хотелось бы или попросту отсутствует. Кроме всего прочего, Microsoft Visual C++ был и остаётся прекрасным средством как для начинающих программистов, которые сегодня познакомятся с языком С++ впервые, так и для более опытных разработчиков, которые желают использовать в своих программах всю мощь ОС Windows!

Итак, убедившись, что установка компилятора прошла успешно, и он появился в группе программ, мы начнём!

Шаг 1 Запуск среды разработки

Запустите Microsoft Visual C++. Дождите сь з агрузки главного окна среды разработки. Его ещё называют IDE - Integrated Developer Enviroment (интегрированная среда разработки). Интегрированная она потому, что сочетает в себе множество самых разных инструментов - от написания WEB-приложений, до графических редакторов для создания курсоров и иконок. А слово developer в мире программистов и вовсе не требует перевода. Девелоперами называются те программисты, которые причастны непосредственно к разработке новых программ (в отличие, например от "баг фиксеров").

Запустив программу, вы увидите пустое окно:

Шаг 2 Выбираем тип проекта:

Далее, выберите пункты меню:

Вы увидите окно New, где представлены различные виды проектов, создание которых возможно в Visual Studio. Как видите, возможностей достаточно много, но сейчас нас интересует Win32 Console Application. Введите в поле Project name имя проекта, например, First, как показано на рисунке, и нажмите ОК.

Шаг 3 Настройки проекта

Проект почти готов, и сейчас нам предлагают указать последние формальности по его настройке

Отметьте "An empty project" ("Пустой проект") и нажмите кнопку "Finish".

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

Шаг 4 Вот Проект Пустой.

Однако это ещё не всё, так как проект пуст. Наша задача добавить в него новые файлы!

В левой части мы видим две вкладки: "Class View" и "File View". Пока проект пуст, в нём нет ни классов, ни файлов.

Шаг 5 Добавление файлов в общую корзину

Выберите в главном меню: Project->Add to Project->New, как это показано на рисунке выше. Мы создадим и добавим в наш проект новый файл.

Нам вновь предлагают выбирать. Поскольку нам нужно добавить файл исходного кода, выберем пункт C++ Source File, а в поле File Name введём "First". Нажмите ОК.

Шаг 6 Наш первый исходник!

Итак, мы добавили в проект новый файл. Но на первый взгляд ничего не изменилось. Выберем вкладку "File View" в левой части окна и откроем группу "First Files", нажав на плюсик.

Раскройте группу First Files во вкладке FileView. Вы увидите, что файлы проекта First разделены на три группы, условно обозначенные папками: "Source Files", "Header Files", "Resource Files". В первой папке будут храниться файлы исходного кода с расширением *.c, *.cpp, во второй - библиотечные файлы с расширением *.h, в третьей - ресурсы проекта, такие, как курсоры, иконки, картинки и т.п. После добавления файла, рядом с группой "Source Files" появился плюсик, нажав на него, мы увидим добавленный нами файл First.cpp. Дважды щёлкнув по нему, мы увидим, как файл раскроется в правой части. Но пока он пуст.

Шаг 7 Первая программа!

Наберите текст исходного файла First.cpp. Например:

main()
int a=2, b=3; //объявляем две целые переменные
int c; //в этой переменной будет храниться ответ
c=a+b; //Это наша сложнейшая формула
printf("Ответ: c = %d", c); //Вывод на ответа на экран
>

Редактор исходного кода автоматически подсвечивает ключевые слова С++ (void, int, #include) синим цветом, а коментарии - зелёным. Это стиль Microsoft. Другие редакторы (Source Insight, Borland C++, C++ Builder, Notepad++ и др.) могут использовать другие цвета.

Но пока весь проект - лишь текстовый файл, написанный на языке С++. Для того, чтобы получить из него выполнимый файл, выберите в меню:

Build->Build First.exe или просто нажмите F7. В нижней части окна вы увидите результат построения исходного файла:

Программа выдала отчёт, и, судя по тому, что количество ошибок и предупреждений равно 0, мы располагаем программой First.exe !

Шаг 8 "Экзекуция" или наслаждение плодами рук своих!

Но как же посмотреть плоды своего труда? Выберите меню: Build->Execute First.exe или нажмите Ctrl+F5. На экране появится наша программа. Если русский текст в окне не читается, как это мы видим на рисунке:

Необходимо будет заменить в команде printf() русские буквы латинскими или перевести фразу на английский:

printf("Result: c = %d", c); //Вывод на ответа на экран

Исправив текст, снова нажмите F7, а затем Ctrl+F5. Как видите, результат будет совсем другой, читаемый:

О заврешении программы говорит фраза "Press any key to continue". После нажатия любой кнопки окно программы будет закрыто.
Если вы хотите читать текст на русском языке, самое простое решение: консольный компилятор вроде Borland C++ 3, запущенный из консольного же диспетчера файлов вроде Far.

Хочу сразу вас предупредить: часть примеров моей книги в Visual C просто не будут работать, так как они используют возможности С++, которые не поддерживаются Microsoft (работа в графическом режиме, генерация прерываний и т.п.). Для таких примеров гораздо более целесообразно использовать Borland C++, в котором будут работать все примеры без исключения.

Для того, чтобы запустить текст новой программы, вы можете вписать его на месте этой, и, запустив Build получить новый исполнимый файл. Или же вы можете создать для неё отдельный проект, что я вам лично очень рекомендую! Таким образом у вас сохранятся все учебные исходники, которые могут сослужить вам хорошую службы, в качестве готовых решений, во-вторых вы быстрее освоитесь с Visual Studio!

Удачи и творческих успехов!

Читать:

Как установить время на микроволновке lg