8-900-374-94-44
[email protected]
Slide Image
Меню

Компиляция c: Процесс компиляции программ на C++ / Хабр

Содержание

Компиляция C++ кода с помощью g++

Для этого урока у вас должна быть установлена программа g++. g++ - производное имя от gcc. gcc - компилятор языка C. Имя gcc образовано от GNU C Compiler. GNU - операционная система, а также это набор свободного ПО, включая gcc и g++ (компиляторы C/C++).

Если вы используете Linux, то g++ уже установлен.

g++ для Windows

Есть пара вариантов, как установить g++ на Windows. Cygwin и MinGW32. MinGW имеет версию для архитектуры x86-64. И именно её мы и будем использовать. Скачайте MinGW-W64, установите, а затем найдите mingw в меню Пуск (MinGW-W64 -> Run Terminal), или зайдите в папку с программой в проводнике (нужно запускать файл mingw-w64.bat). Вы увидите командную строку Windows.

Работа с командной строкой Windows

Если вы никогда не использовали командную строку, то вот несколько полезных команд:

d: c: cd folder1 cd ..

Имя диска с двоеточием - перейти на определённый диск. Например, я храню код на диске D, поэтому моей первой командой будет:

d:

cd - изменить директорию (change directory). Эта команда переместит вас в нужную директорию. Я храню код для данных уроков в папке: d:\prog\cpp. Поэтому, после того как я выбрал диск D, я обычно ввожу следующую команду:

cd prog\cpp

cd .. (две точки) переместит вас в папку выше.

Исходный код

Создайте файл hello_world.cpp в папке, где вы планируете хранить свой код. Откройте его в простом текстовом редакторе: Notepad/Gedit/Notepad++/Sublime... И вставьте следующий текст:

#include <iostream> int main() { cout << "Hello World\n"; return 0; }

Эта программа напечатает строку Hello World в консоли. Мы обсудим, что означает данный код, в следующем уроке.

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

Компиляция C++ кода с помощью компилятора g++

g++ <filename>

g++ hello_world.cpp

После выполнения данной команды, в текущей директории будут создан файл: a.out или a.exe. Чтобы запустить программу, введите имя файла в консоли и нажмите Ввод (Enter). В консоли вы увидите текст Hello World. После этого программа сразу завершится.

a.out - имя по умолчанию для скомпилированных файлов. Мы можем изменить его:

g++ -o <output_filename> <filename> g++ -o hello_world.exe hello_world.cpp

Выполнив последнюю команду, мы получим файл hello_world.exe. После этого в Windows скомпилированную программу можно выполнить следующей командой:

hellow_world.exe

А в Linux:

./a.out

Компиляция (compilation) и связывание (linking)

Во время компиляции происходит два шага. Первый - компиляция файлов с исходным кодом. Результат этого шага: объектный код. Объектный код помещается в файлы с расширением .o. Следующий шаг - связывание (linking). Специальная программа - компоновщик (linker), берёт объектные файлы и "связывает" их вместе. Компоновщик необходим, когда есть больше одного файла с исходным кодом. Пока наши программы будут состоять из одного файла. Но в будущем нам понадобится компоновщик.

Заключение

Мы рассмотрели как компилируется C++ код с помощью компилятора g++. Теперь мы готовы к изучению C++. А начнём мы с разбора программы Hello World.

Упражнения

  1. Скомпилируйте hello_world.cpp

Бесплатные компиляторы и интерпретаторы C / C

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

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

В этой статье перечислены бесплатные компиляторы C и C++ для различных операционных систем.

Он может работать и создавать исполняемые файлы под Windows (16-разрядные, 32-разрядные и 64-разрядные версии), Linux (32-разрядные и 64-разрядные версии), OS / 2 и MS-DOS (16-разрядные и 32-разрядные режимы). Стоит пояснить, что Watcom — это был известный коммерческий компилятор, пока первоначальные разработчики не прекратили его продажи и не опубликовали исходный код (в соответствии с публичной лицензией Sybase Open Watcom).

Для индивидуальных или начинающих программистов Microsoft Visual Studio Community включает в себя много важных инструментов из коммерческих версий проекта. Вы получите в свое распоряжение IDE, отладчик, оптимизирующий компилятор, редактор, средства отладки и профилирования. С помощью этого пакета можно разрабатывать программы для настольных и мобильных версий Windows, а также Android. Компилятор C++ поддерживает большинство функций ISO C++ 11, некоторые из ISO C++ 14 и C++ 17. В то же время компилятор C уже безнадежно устарел и не имеет даже надлежащей поддержки C99.

Программное обеспечение также поставляется с поддержкой построения программ на C#, Visual Basic, F# и Python. В то время, когда я писал эту статью, на сайте проекта утверждалось, что Visual Studio Community 2015 «бесплатный инструмент для индивидуальных разработчиков, проектов с открытым исходным кодом, научных исследований, образовательных проектов и небольших профессиональных групп».

Clang — компилятор C, C++, Objective C и Objective C++, разработанный под Apple. Это часть проекта LLVM. Clang реализует различные стандарты ISO C и C++, такие как C11, ISO C++ 11, C++ 14 и частично C++ 1z.

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

Проект MinGW-w64 предоставляет библиотеки, заголовки, необходимые компиляторам C и C++ GNU для работы в системе Windows. В случае MinGW-w64 эти файлы поддержки позволяют создавать 64-битные программы в дополнение к 32-битным. Проект также предоставляет кросс-компиляторы, так что можно скомпилировать программу Windows из системы Linux.

Это версия набора компиляторов Open64 (описанного ниже), которая была настроена для процессоров AMD и имеет дополнительные исправления ошибок. Компилятор C / C++ соответствует стандартам ANSI C99 и ISO C++ 98, поддерживает межъязыковые вызовы (так как он включает в себя компилятор Fortran), 32-битный и 64-битный код x86, векторную и скалярную генерацию кода SSE / SSE2 / SSE3, OpenMP 2.5 для моделей с разделяемой памятью, MPICh3 для моделей с распределенной и разделяемой памятью; содержит оптимизатор, поддерживающий огромное количество оптимизаций (глобальную, цикл-узел, межпроцедурный анализ, обратную связь) и многое другое. Набор поставляется с оптимизированной AMD Core Math Library и документацией. Для этого набора компиляторов требуется Linux.

Является бесплатным компилятором для Windows 7 с открытым исходным кодом. Он генерирует код для Win32, Windows 3.1 (Win16), OS / 2, Netware NLM, MSDOS (16-битный и 32-битный режим) и т. д. Watcom был очень популярным компилятором несколько лет назад до тех пор, пока Sybase не закрыла его. Он также включает в себя довольно известный STLport (реализация библиотеки стандартных шаблонов C++). Обновление: этот проект, похоже, застопорился, и в настоящее время запущен новый проект Open Watcom V2 Fork (описан выше).

Digital Mars C / C ++ является заменой Symantec C++ с поддержкой компиляции программ для Win32, Windows 3.1, MSDOS и 32-разрядных расширенных MSDOS. Если используемый ПК не имеет процессора с плавающей запятой (машины pre-Pentium), можно связать эмуляцию с плавающей запятой в вашей программе. Компилятор поддерживает определение C++ из аннотированного руководства по C++ (ARM) и расширенные функции языка AT & T версии 3.0, включая шаблоны, вложенные классы, вложенные типы, обработку исключений и идентификацию типа во время выполнения.

Это графический отладчик уровня исходного кода для X Window, который содержит встроенный интерпретатор языка C. Он может обрабатывать один или несколько исходных файлов. Можно использовать его для создания исполняемого файла с байтовым кодом и выполнения интерпретатора в этом исполняемом файле. Если вам нужен интерпретатор для отладки или создания прототипов программ, или просто для изучения языка, попробуйте этот инструмент. Он поддерживает следующие платформы: Solaris, SunOS, Linux, FreeBSD, BSD / OS и некоторые другие Unix-платформы.

Помните старый (популярный) компилятор C BDS для систем CP / M 8080 / Z80? В настоящее время этот компилятор языка C находится в публичном доступе, в комплекте с исходным кодом языка ассемблера. Пакет представляет собой розничную версию компилятора с компоновщиком и руководством пользователя. Его можно использовать для простой генерации кода 8080/8085 / Z80 для встраиваемых систем (то есть создавать собственные процедуры для замены любого кода библиотеки, который обращается к функциям операционной системы).

Это интегрированная среда разработки Win32, включающая в себя компилятор C++ egcs и отладчик GNU из среды Mingw32. А также редактор и другие средства, облегчающие разработку программ с использованием компилятора Mingw32 gcc на платформе Windows. Он также содержит программу установки для приложений.

Он работает как в Windows, так и в DOS, имеет интегрированную среду разработки с редактором программ (с подсветкой синтаксиса и автоматическим завершением кода). Он может генерировать программы для Win32 и MSDOS, а также файлы Intel и Motorola hex (что полезно, если вы пишете программы для встроенных систем). Для вывода MSDOS ваши программы будут использовать расширитель DOS.

DeSmet C должен быть знаком тем, кто программировал на C в 1980-х годах. Это компилятор C для MSDOS. Он был выпущен под лицензией GNU GPL и поставляется с руководствами, редактором и сторонним оптимизатором.

Xcode — это интегрированная среда разработки Apple, которая включает в себя редактор с подсветкой синтаксиса, систему управления сборкой, отладчик, компилятор C GNU (gcc), конструктор интерфейса, AppleScript Studio, поддержку разработки на Java, инструменты разработки WebObjects. Чтобы получить в свое распоряжение данные инструменты необходимо быть участником Apple Developer Connection (ADC). Но онлайн-членство является бесплатным.

Этот небольшой компилятор C для Linux и Windows генерирует оптимизированные двоичные файлы x86. Утверждается, что он собирает, компонует и связывает код в несколько раз быстрее, чем GCC. В настоящий момент разработчики стремятся обеспечить соответствие ISO C99. Компилятор также включает необязательную проверку границ. Он обрабатывает файлы скриптов C (просто добавьте в Linux shebang код #!/usr/local/bin/tcc -run в первую строку исходного кода на C, чтобы он выполнялся напрямую). TCC распространяется под лицензией GNU General Public License.

Это набор библиотек классов и компилятор Objective C, который преобразует код Objective C в простой C-код. Работает на Windows, Linux, OS / 2, Macintosh и т. д.

Эта система поставляется с компилятором GNU C / C++, который можно использовать для создания исполняемых файлов Win32. Она содержит собственный <windows.h>, который находится в открытом доступе. Предполагается, что приложения, созданные с использованием этой системы, будут быстрее, чем, те которые созданы с помощью Cygwin32, и они не ограничиваются положениями лицензии GNU. Mingw32 поставляется с инструментами для обработки текста (sed, grep), генератором лексического анализатора (flex), генератором парсеров (bison) и т. д. Mingw32 также поставляется с компилятором ресурсов Windows.

На странице компилятора C GNU можно получить ссылки на бинарные файлы и исходный код для компилятора GNU C. Также можно использовать приведенные в этой статье ссылки на наиболее часто запрашиваемые бинарные версии (MSDOS и Win32).

Еще один компилятор C, основанный на LCC (смотрите также LCC-Win32). Он включает в себя компилятор C, компоновщик, компилятор ресурсов, сообщений, утилиту make и другие инструменты. Он компилирует код для Windows и Pocket PC.

Пользователи Linux / Alpha теперь могут бесплатно скачивать и использовать компилятор Compaq, просто заполнив форму и приняв лицензионное соглашение. Компилятор может использоваться для генерации любых программ, коммерческих или иных. Он включает в себя математическую библиотеку и отладчик (ladebug), перенесенный из True64 Unix. Он поставляется с обычными справочными страницами, а также справочником по языку и руководством программиста.

Интерпретатор C / C++, поддерживающий стандарт ISO 1990 C (C90), основные функции C99, классы C++, а также расширения к языку С, такие как вложенные функции, строковый тип и т. д. Он может быть встроен в другие приложения и аппаратные средства, использоваться в качестве языка сценариев. Код C / C++ интерпретируется напрямую без компиляции промежуточного кода. Поскольку этот интерпретатор поддерживает Linux, Windows, MacOS X, Solaris и HP-UX, созданный вами код можно перенести на любую из этих платформ. Стандартная версия бесплатна для личного, академического и коммерческого использования. Для загрузки пакета необходимо зарегистрироваться.

Это система разработки, основанная на хорошо известном компиляторе C / C++ GNU. Она генерирует 32-разрядные исполняемые файлы MSDOS, которые являются файлами с длинными именами Windows 95. Это очень функциональная система с IDE, графическими библиотеками, генераторами лексического анализатора (flex), генераторами парсеров (bison), утилитами обработки текста и так далее. Компилятор языка C, утилиты и библиотеки поставляются с исходным кодом.

Cilk — это язык на основе ANSI C, который может использоваться для многопоточного параллельного программирования. Это особенно эффективно для использования динамического, высоко асинхронного параллелизма в стиле параллельных данных или передачи сообщений. На официальном сайте упоминается, что Cilk уже используется для разработки трех шахматных программ мирового класса: StarTech, Socrates и Cilkchess.

Это своего рода сочетание компилятора C и ассемблера, который позволяет «создавать программы с возможностями и читабельностью C, сохраняя при этом эффективность языка ассемблера». Он может создавать исполняемые файлы MSDOS или файлы .OBJ, которые можно применять вместе с другими компоновщиками для создания исполняемого файла. По приведенной выше ссылке можно найти исходный код и документацию для компилятора. Если вы хотите получить предварительно скомпилированный бинарный файл, это можно сделать на неофициальном сайте компилятора C— Sphinx.

Сайт этого компилятора написан на японском языке. Он выглядит как кросс-компилятор, позволяющий генерировать код для ROM. Старая версия компилятора (3.30c) предоставляется бесплатно. Бесплатная версия работает только на MSDOS.

Это кросс-компилятор C, предназначенный для микропроцессоров Intel 8051, DS390, Z80, HC08 и PIC. Он также может быть переназначен для других 8-битных микроконтроллеров или ОСТО. SDCC поставляется с перенастраиваемым ассемблером и компоновщиком, отладчиком исходного уровня и симулятором. Библиотеки совместимы со стандартом C99. Исходный код для компилятора доступен под лицензией GPL. Поддерживаются такие платформы, как Linux, Windows, Mac OS X, Alpha, Sparc и другие.

Это компилятор ANSI C для MSDOS / DPMI и Win32, который поставляется с библиотекой среды выполнения, компоновщиком, отладчиком, DOS-расширителем (версия MSDOS), IDE (версия Win32) и утилитой make. Также доступен исходный код. При работе в режиме совместимости с C99 он компилирует большинство конструкций C99.

Этот «проект» включает в себя коммерческий компилятор (GNU C / C++), который генерирует графический интерфейс Win32 и консольные приложения. Предоставляется исходный код компилятора, библиотек и инструментов. Обратите внимание, что опция по умолчанию в этом пакете требует от вас распространять исходный код, если вы компилируете и связываетесь со своими библиотеками. Существует также специальная вызываемая опция, которая задает возможность связи с альтернативными библиотеками, позволяя распространять свои приложения без источников.

Это компилятор C для Windows, который генерирует графический интерфейс Win32 и консольные приложения. Он поставляется со своим собственным компоновщиком, IDE, отладчиком, редактором и компилятором ресурсов. LCC-Win32 основан на компиляторе LCC и является бесплатным только для некоммерческого использования.

LCC — это компилятор C (только исходный код), который генерирует код для Alpha, Sparc, MIPS R3000 и Intel x86. Он является основой как минимум для двух других компиляторов Win32 C (также описанных выше).

Cyclone C не является компилятором ANSI C в строгом значении, а представляет собой компилятор «безопасного диалекта» C. Он обеспечивает безопасность типов, имеет множество проверок для защиты от переполнения буфера, связанных с массивами нарушений и т. д. В настоящее время он работает на Linux и Windows (в последнем случае через Cygwin), для него требуется наличие в системе инструментов компиляции GNU.

Это IDE на базе Macintosh, компилятор и отладчик для программ на C. Он включает в себя редактор с подсветкой синтаксиса, ANSI C компилятор, компилятор для языка визуализации ALPHA, редактор графов, обратимый виртуальный процессор и т. д.

Обратите внимание, что программы в код, который будет выполняться для виртуального ЦПУ. Виртуальная машина и отладчик позволяют выполнять код вперед и назад и поддерживать многозадачность. IDE поставляется с анимированными алгоритмами, примерами исходного кода таких игр, как Tetris, Checkers и других. IDE полезна для проверки и отладки исходного кода, поиска процессов, неэффективно использующих память и т. д.

Примечание: этот проект был прекращен.

Старый, но проверенный Turbo C 2.01 для DOS доступен бесплатно по решению новых владельцев Borland. Это был популярный компилятор C во времена MSDOS, известный своей быстрой сборкой, интегрированной средой разработки («IDE») и графической библиотекой (DOS).

Данная публикация представляет собой перевод статьи «Free C/C++ Compilers and Interpreters» , подготовленной дружной командой проекта Интернет-технологии.ру

Компиляция исходников (cpp, cs) компилятором Visual Studio без запуска IDE в Windows / Хабр

Частенько нет необходимости запускать тяжеловесную IDE Visual Studio для компиляции небольших приложений, проведения каких-либо тестов кода, не требующего полномасштабной отладки. В подобных случаях можно оперативно собрать приложение в консольном режиме, используя возможности предоставляемые компилятором от Microsoft (cl.exe) и запускными модулями IDE (devenv.exe, msdev.exe). Далее приводится код файлов сценариев (cmd) интерпретатора командной строки Windows, который с небольшими изменениями каждый может настроить под себя, с учётом путей к Visual Studio в своей системе.

Компиляция cpp-файлов

Код сценария vc++_compile_and_link.cmd
:: --------------------------------------------------------------------------- ::
:: Перед использованием сценария рекомендуется задать системные переменные:    ::
:: sVSPath     - путь к корневому каталогу Visual C++,                         ::
:: sVSPathName - путь к основному исполнимому файлу Visual C++                 ::
:: (либо раскомментировать и отредактировать sVSPath, sVSPathName ниже в файле.::
:: --------------------------------------------------------------------------- ::
echo off
cls

echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 

:: -------------------------------------- ::
::     Имена исходников (через пробел)    ::
:: -------------------------------------- ::
set gavSrc=MySource1.cpp MySource2.cpp


:: -------------------------------------- ::
:: Дополнительно, если необходимо, для Qt ::
:: - заголовочный файл,содержащий Q_OBJECT::
:: из него будет сгенерирован moc_xxx.cpp ::
:: -------------------------------------- ::
::set gavSrcQtMoc=gavQtSignalSlot.h
set gavSrcQtMoc=""

:: -------------------------------------- ::
:: Версия компилятора:                    ::
::    6 - VC6,                            ::
::    8 - VC8 (2005),                     ::
::    9 - VC9,                            ::
::   10 - VC10 (2010)                     ::
::   11 - VC11 (2012)                     ::
:: -------------------------------------- ::
set iCompVer=11


:: -------------------------------------- ::
:: Режим компиляции:                      ::
::    0 - release,                        ::
::    1 - debug,                          ::
::    2 - генерирует прототипы функций    ::
::        (без компиляции)                ::
:: -------------------------------------- ::
set iModeComp=1

:: -------------------------------------- ::
::  Флаги наличия библиотеки:             ::
::      0 - нет, 1 - есть                 ::
:: -------------------------------------- ::
set bLibQt=0
set bLibCrt=0
set bLibBoost=0

:: -------------------------------------- ::
:: Режим линковки с Qt:                   ::
::    0 - shared (динамическая),          ::
::    1 - static (статическая)            ::
:: -------------------------------------- ::
set iModeQt=0

:: -------------------------------------- ::
:: Флаги специальных WINDDK               ::
::    0 - не используется                 ::
::    1 - WINDDK для Win2000, WinXP       ::
::        (в этом случае д.б. верно заданы::
::         gavIncPathDdkXP,gavLibPathDdkXP::
::         - см. ниже)                    ::
:: -------------------------------------- ::
set iWinddk=0

:: -------------------------------------- ::
::    Дополнительные флаги компилятора    ::
::   ( дефайны задавать так: -Dдефайн )   ::
:: -------------------------------------- ::
::set gavCompilFlags=-Dtest


:: -------------------------------------- ::
::     Подсистема приложения (одна из)    ::
:: -------------------------------------- ::
:: Win32 character-mode application: 
set gavSubsystem=CONSOLE
:: Application does not require a console:
::set gavSubsystem=WINDOWS
:: Device drivers for Windows NT:
::set gavSubsystem=NATIVE
:: Application that runs with the POSIX subsystem in Windows NT:
::set gavSubsystem=POSIX
:: Application that runs on a Windows CE device:
::set gavSubsystem=WINDOWSCE



:: -------------------------------------- ::
::          Пути к Visual Studio.         ::
::          !!! без кавычек !!!           ::
:: -------------------------------------- ::
:: VS6 (!! Путь к компилятору VS6 д.б. коротким и без пробелов - иначе ошибка линковки)
if %iCompVer%==6 set sVSPath=C:\Progs\VC98
if %iCompVer%==6 set sVSPathName=%sVSPath%\bin\cl.exe

:: VS8 
if %iCompVer%==8 set sVSPath=%SYSTEMDRIVE%\Program Files\Microsoft Visual Studio 8\VC
if %iCompVer%==8 set sVSPathName=%sVSPath%\bin\cl.exe

:: VS9
if %iCompVer%==9 set sVSPath=%SYSTEMDRIVE%\Program Files\Microsoft Visual Studio 9.0\VC
if %iCompVer%==9 set sVSPathName=%sVSPath%\bin\cl.exe

:: VS10
if %iCompVer%==10 set sVSPath=%SYSTEMDRIVE%\Program Files\Microsoft Visual Studio 10.0\VC
if %iCompVer%==10 set sVSPathName=%sVSPath%\bin\cl.exe
                   :: доп.пути для VS2010:
if %iCompVer%==10 set gavIncPathMy=%SYSTEMDRIVE%\Program Files\Microsoft SDKs\Windows\v7.0A\Include
if %iCompVer%==10 set gavLibPathMy=%SYSTEMDRIVE%\Program Files\Microsoft SDKs\Windows\v7.0A\Lib

:: VS11
if %iCompVer%==11 set sVSPath=%SYSTEMDRIVE%\Program Files (x86)\Microsoft Visual Studio 11.0\VC
if %iCompVer%==11 set sVSPathName=%sVSPath%\bin\cl.exe
                   :: доп.пути для VS2010:
if %iCompVer%==11 set gavIncPathMy=%SYSTEMDRIVE%\Program Files (x86)\Windows Kits\8.0\Include\um
if %iCompVer%==11 set gavIncPathMy2=%SYSTEMDRIVE%\Program Files (x86)\Windows Kits\8.0\Include\Shared
if %iCompVer%==11 set gavLibPathMy=%SYSTEMDRIVE%\Program Files (x86)\Windows Kits\8.0\Include\Lib
if %iCompVer%==11 set gavLibPathMy2=%SYSTEMDRIVE%\Program Files (x86)\Windows Kits\8.0\Lib\win8\um\x86
::if %iCompVer%==11 set gavLibPathMy2=%SYSTEMDRIVE%\Program Files (x86)\Windows Kits\8.0\Lib\win8\um\x64

echo Compilator version: VC%iCompVer%
echo Compilator path: %sVSPathName%

:: -------------------------------------- ::
::              Пути к Boost              ::
:: -------------------------------------- ::
set BOOST_ROOT=C:\Progs\boost\boost_1_49_0


:: -------------------------------------- ::
::     Настройка путей к подключаемым     ::
::  файлам.   Каждый путь должен быть     ::
::         отдельной переменной !         ::
:: -------------------------------------- ::
set gavIncPathVS="%sVSPath%\include"
set gavIncPathQt="%QTDIR%\include"
set gavIncPathBoost="%BOOST_ROOT%"
set gavIncPathDdkCrt="C:\Progs\WINDDK\2600.1106\inc\crt"
set gavIncPathDdkXP="C:\Progs\WINDDK\2600.1106\inc\w2k"

if not "%gavIncPathMy%"=="" (set gavIncPathAll=-I"%gavIncPathMy%" 
                             if not "%gavIncPathMy2%"=="" (
                                                           set gavIncPathAll=-I"%gavIncPathMy%" -I"%gavIncPathMy2%"
                                                          )
                            )
if %iWinddk%==1 (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathDdkCrt% -I%gavIncPathDdkXP%)
if not %gavIncPathVS%=="" (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathVS%)
if %bLibQt%==1 (if not %gavIncPathQt%=="" (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathQt%))
if %bLibBoost%==1 (if not %gavIncPathBoost%=="" (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathBoost%))
echo Include pathes: %gavIncPathAll%


:: -------------------------------------- ::
::  Настройка путей к библиотечным (.lib) ::
::  файлам.   Каждый путь должен быть     ::
::         отдельной переменной !         ::
:: -------------------------------------- ::
set gavLibPathDdkXP=C:\Progs\WINDDK\2600.1106\lib\wxp\i386
set gavLibPathVS=%sVSPath%\lib

set gavLibPathAll=""
if %iWinddk%==1 (set gavLibPathAll=%gavLibPathAll% /LIBPATH:"%gavLibPathDdkXP%")
if not "%gavLibPathVS%"=="" (set gavLibPathAll=%gavLibPathAll% /LIBPATH:"%gavLibPathVS%")
if not "%gavLibPathMy%"=="" (set gavLibPathAll=%gavLibPathAll% /LIBPATH:"%gavLibPathMy%"
                             if not "%gavLibPathMy2%"=="" (
                                                           set gavLibPathAll=%gavLibPathAll% /LIBPATH:"%gavLibPathMy%" /LIBPATH:"%gavLibPathMy2%"
                                                          )
                            )

set gavLibPathBoost="%BOOST_ROOT%\stage\lib"
if %bLibBoost%==1 (if not %gavLibPathBoost%=="" (set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathBoost%))

set gavLibPathQtReleaseShared="%QTDIR%\lib\release\shared"
set gavLibPathQtReleaseStatic="%QTDIR%\lib\release\static"
set gavLibPathQtDebugShared="%QTDIR%\lib\debug\shared"
set gavLibPathQtDebugStatic="%QTDIR%\lib\debug\static"
if %bLibQt%==1 (
                 if %iModeComp%==0 (
                                    if %iModeQt%==0 (
                                                     echo Qt mode: release shared
                                                     set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathQtReleaseShared%
                                                    )
                                    if %iModeQt%==1 (
                                                     echo Qt mode: release static
                                                     set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathQtReleaseStatic%
                                                    )
                                   )
                 if %iModeComp%==1 (
                                    if %iModeQt%==0 (
                                                     echo Qt mode: debug shared
                                                     set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathQtDebugShared%
                                                    )
                                    if %iModeQt%==1 (
                                                     echo Qt mode: debug static
                                                     set gavLibPathAll=%gavLibPathAll% /LIBPATH:%gavLibPathQtDebugStatic%
                                                    )
                                   )
               )
echo Lib pathes: %gavLibPathAll%

:: -------------------------------------- ::
::      Файлы библиотеки run-time.        ::
:: При необходимости добавить сюда нужные ::
:: -------------------------------------- ::
set gavLibFilesCrt=""
if %bLibCrt%==1 (set gavLibFilesCrt=user32.lib ole32.lib Gdi32.lib Ws2_32.lib Imm32.lib Comdlg32.lib Winspool.lib Advapi32.lib)
if not "%gavLibFilesCrt%"=="" (set gavLibFilesAll=%gavLibFilesCrt%)

:: -------------------------------------- ::
::         Файлы библиотеки Qt.           ::
:: -------------------------------------- ::
set gavLibFilesQtShared=qtmain.lib qt-mt333.lib
set gavLibFilesQtStatic=qtmain.lib qt-mt.lib

if %bLibQt%==1 (
                if %iModeQt%==0 (set gavLibFilesAll=%gavLibFilesAll% %gavLibFilesQtShared%)
                if %iModeQt%==1 (set gavLibFilesAll=%gavLibFilesAll% %gavLibFilesQtStatic%)
               )

echo Lib files: %gavLibFilesAll%


:: -------------------------------------- ::
::     Настройка режимов компиляции       ::
:: -------------------------------------- ::
if %iModeComp%==0 (
               set gavLinkMode=/RELEASE
               :: для DLL: set gavCompMode=/MD
               set gavCompMode=/MT
               set gavOptimize=/O2 /GA
              )

if %iModeComp%==1 (
               set gavLinkMode=/DEBUG
               :: для DLL: set gavCompMode=/MDd
               set gavCompMode=/MTd
               ::set gavOptimize=/Od /ZI
               set gavOptimize=/Od /Z7
              ) 

if %iModeComp%==2 (
               set gavLinkMode=
               set gavCompMode=
               set gavOptimize=/Zg
              ) 

if %bLibQt%==1 (if %iModeQt%==1 (set gavCompMode=/MDd))

:: -------------------------------------- ::
::    Настройка подсистемы приложения     ::
:: -------------------------------------- ::
if not %gavSubsystem%=="" (set gavLinkSubsys=/SUBSYSTEM:%gavSubsystem%)


:: -------------------------------------- ::
::         Настройка компилятора          ::
:: -------------------------------------- ::
if %bLibQt%==1 (
                if %iModeQt%==0 (set gavCompilFlags=%gavCompilFlags% -DQT_DLL)
               )

:: -------------------------------------- ::
::        Удаление старых файлов          ::
:: -------------------------------------- ::
set gavOldObj=%gavSrc:.cpp=.obj,%
set gavOldObj=%gavOldObj:.c=.obj,%
set gavOldAsm=%gavOldObj:.obj=.asm%
for /F "tokens=1" %%A in ("%gavSrc%") do (set gavMainName=%%A)
set gavMainName=%gavMainName:.cpp=%
set gavMainName=%gavMainName:.c=%
set gavDelExt= %gavMainName%.exe, %gavMainName%.pdb, %gavMainName%.ilk, %gavOldObj% %gavOldAsm% __vc++_%gavMainName%.log
echo. 
echo Deleting old files: %gavDelExt% ...
echo. 
del %gavDelExt%
echo. 
echo ------------------
echo Compiling start...
echo ------------------
echo. 

if %bLibQt%==1 (if not %gavSrcQtMoc%=="" (
echo ------------------
echo Mocing file... 
echo ------------------
echo on
%QTDIR%\bin\moc %gavSrcQtMoc% -o moc_%gavSrcQtMoc%.cpp
@echo off
set gavSrc=%gavSrc% moc_%gavSrcQtMoc%.cpp
))

echo on
"%sVSPathName%" /EHsc %gavIncPathAll% %gavCompilFlags% /Fa %gavSrc% %gavCompMode% %gavOptimize% /link %gavLinkSubsys% %gavLinkMode% %gavLibPathAll% %gavLibFilesAll%>"__vc++_%gavMainName%.log"

@echo off
echo. 
echo ------------------
echo Compiling end...
echo ------------------
echo. 
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
:: -------------------------------------- ::
pause

Основные параметры, которые следует однократно настроить в вышеприведённом сценарии:
1) в разделе «Пути к Visual Studio» необходимо задать пути к файлам различных версий Visual Studio (если у вас их установлено несколько):

  • sVSPath — путь к основному каталогу Visual Studio т.е. к корневому каталогу, в котором содержатся все прочие подкаталоги для данной версии VS.
  • gavIncPathMy — возможно для VS 11.0 потребуется задать свои пути к подключаемым заголовочным файлам.

2) в разделе «Пути к Boost» можно задать BOOST_ROOT — путь к коревому каталогу библиотеки Boost (если она у вас установлена).
3) в разделе «Настройка путей к подключаемым файлам» при необходимости можно задать пути к заголовочным файлам Qt, WinDDK.
4) в разделе «Настройка путей к библиотечным (.lib) файлам» задаются пути к файлам библиотек (в частности для WinDDK).

Реже может возникнуть необходимость настроить следующие параметры под конкретный проект:
iCompVer — версия используемого компилятора (6 — для VC6, 8 — VC8 (2005), 9 — VC9, 10 — VC10 (2010), 11 — VC11 (2012).
gavLibFilesQtShared — имена .lib-файлов для динамически подключаемой библиотеки Qt;
gavLibFilesQtStatic — имена .lib-файлов для статически линкуемой библиотеки Qt.
gavLibFilesCrt — имена .lib-файлов для стандартных динамических библиотек, используемых в Windows.
iModeQt — режим линковки библиотеки Qt.
gavCompMode — флаги режима компиляции (однопоточные, многопоточные и т.п.).
gavOptimize — флаги оптимизации кода компилятором.

Чаще всего приходится менять параметры:
gavSrc — имена файлов с исходным кодом, разделённые пробелом (если их несколько).
bLibQt — флаг (0/1) необходимости использовать библиотеку Qt при сборке приложения.
bLibCrt — флаг (0/1) необходимости использовать стандартные CRT-библиотеки Windows при сборке приложения.
bLibBoost — флаг (0/1) необходимости использовать библиотеку Boost при сборке приложения.
gavSubsystem — подсистема создаваемого приложения: CONSOLE — консольное, WINDOWS — с графическим интерфейсом.

Результат (ошибки, сообщения) компиляции можно просмотреть в файле __vc++_XXX.log, где XXX — имя основного исходного файла

Сборка cpp-приложения из файлов проектов

Аналогично без запуска IDE можно собрать проект, используя файлы проектов и воркспейсов (dsp, dsw).
Код сценария vc++_dsp_dsw_compile.cmd
:: Перед использованием сценария рекомендуется задать системную переменную sVSPathName,
:: указывающую путь к основному исполнимому файлу Visual Studio либо раскомментировать 
:: и отредактировать sVSPathName ниже в этом файле...
@echo off
cls

echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
:: -------------------------------------- ::
:: имя файла проекта (dsp) или вокспейса (dsw):
set sPrjFile=MyWorkspace.dsp

:: -------------------------------------- ::
:: Режим компиляции: 0 - release, 1 - debug, 2 - release и debug:
set iMode=2

:: -------------------------------------- ::
:: Режим обработки файлов: 
::        0 - удаление промежуточных файлов, 
::        1 - перекомпиляция изменившихся фйлов,
::        2 - полная пересборка проекта (рекомендуется при iMode=2)
set iSubMode=2


:: -------------------------------------- ::
:: Имя конфигурации:
if %sPrjFile:.dsp=% == %sPrjFile% (
   set sPrjName=%sPrjFile:.dsw=%
  ) ELSE (
   set sPrjName=%sPrjFile:.dsp=%
  )

:: Имя конфигурации - для режима release: 
set sConfigNameRelease="%sPrjName% - Win32 Release"
:: Имя конфигурации - для режима debug: 
set sConfigNameDebug="%sPrjName% - Win32 Debug"


:: -------------------------------------- ::
:: пути к Visual Studio:
:: set sVSPathName=%SYSTEMDRIVE%\Program Files\Microsoft Visual Studio 6.0\Common\MSDev98\Bin\MSDEV.EXE
:: set sVSPathName=%SYSTEMDRIVE%\Program Files\Microsoft Visual Studio 8\Common7\IDE\VCExpress.exe
:: set sVSPathName=%SYSTEMDRIVE%\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe

:: -------------------------------------- ::
:: Подрежим:

if %iSubMode%==0 (
               set iCompMode=/CLEAN
              )

if %iSubMode%==1 (
               set iCompMode=
              ) 

if %iSubMode%==2 (
               set iCompMode=/REBUILD
              ) 

:: -------------------------------------- ::
echo. 
echo ---------------------------------
echo [%sPrjName%]: compiling start...
echo ---------------------------------
echo. 
@echo off

if %iMode%==0 (
:: режим release: 
echo [%sPrjName%]: configuration mode:
echo     %sConfigNameRelease%
echo on
"%sVSPathName%" %sPrjFile% /MAKE %sConfigNameRelease% %iCompMode% /OUT __vc++_compile_release.log
)

@echo off
if %iMode%==1 (
:: режим debug: 
echo [%sPrjName%]: configuration mode:
echo     %sConfigNameDebug%
echo on
"%sVSPathName%" %sPrjFile% /MAKE %sConfigNameDebug% %iCompMode% /OUT __vc++_compile_debug.log
)
 
@echo off
if %iMode%==2 (
:: режим release и debug: 
echo [%sPrjName%]: configuration modes: 
echo     %sConfigNameRelease%
echo     %sConfigNameDebug%
echo on
"%sVSPathName%" %sPrjFile% /MAKE %sConfigNameRelease% %iCompMode% /OUT __vc++_compile_release.log
"%sVSPathName%" %sPrjFile% /MAKE %sConfigNameDebug%   %iCompMode% /OUT __vc++_compile_debug.log
)


@echo off
echo. 
echo ---------------------------------
echo [%sPrjName%]: compiling end.
echo ---------------------------------
echo. 
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
:: -------------------------------------- ::
pause

Компиляция cs-файлов

Вышерассмотренный функционал реализуем и для C#:
Код сценария vc#_compile_and_link.cmd
:: --------------------------------------------------------------------------- ::
:: Перед использованием сценария рекомендуется задать системные переменные:    ::
:: sVSPath     - путь к корневому каталогу Visual C#,                          ::
:: sVSPathName - путь к основному исполнимому файлу Visual C#                  ::
:: (либо отредактировать sVSPath, sVSPathName ниже в файле.::
:: --------------------------------------------------------------------------- ::
echo off
cls

echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 

:: -------------------------------------- ::
::     Имена исходников (через пробел)    ::
:: -------------------------------------- ::
set gavSrc=Program.cs


:: -------------------------------------- ::
:: Режим компиляции:                      ::
::    0 - release,                        ::
::    1 - debug,                          ::
:: -------------------------------------- ::
set iModeComp=1

:: -------------------------------------- ::
::     Подсистема приложения (одна из)    ::
:: -------------------------------------- ::
:: /target:exe                    Построить консольный исполняемый файл (по умолчанию) (Краткая форма: /t:exe)
set gavSubsystem=exe
:: /target:winexe                 Построить исполняемый файл Windows  (Краткая форма: /t:winexe)
::set gavSubsystem=winexe
:: /target:library                Построить библиотеку (Краткая форма: /t:library)
::set gavSubsystem=library
:: /target:module                 Построение модуля, который может быть добавлен в другую сборку (Краткая форма: /t:module)
::set gavSubsystem=module
:: /target:appcontainerexe        Построение исполняемого файла Appcontainer (Краткая форма: /t:appcontainerexe)
::set gavSubsystem=appcontainerexe
:: /target:winmdobj               Построение промежуточного файла среды выполнения Windows, используемого WinMDExp (Краткая форма: /t:winmdobj)
::set gavSubsystem=winmdobj

:: -------------------------------------- ::
::      ПЛАТФОРМА приложения (одна из)    ::                                  
::    (x86, Itanium, x64, arm или anycpu. ::
::      Платформа по умолчанию: anycpu.)  ::
:: -------------------------------------- ::
set gavPlatform=anycpu

:: -------------------------------------- ::
::    Дополнительные флаги компилятора    ::
:: -------------------------------------- ::
::set gavCompilFlags=

:: -------------------------------------- ::
::          Пути к Visual Studio.         ::
::          !!! без кавычек !!!           ::
:: -------------------------------------- ::
 set sVSPath=%WINDIR%\Microsoft.NET\Framework\v4.0.30319
 set sVSPathName=%sVSPath%\csc.exe

:: -------------------------------------- ::
::     Настройка путей к подключаемым     ::
::  файлам.   Каждый путь должен быть     ::
::         отдельной переменной !         ::
:: -------------------------------------- ::
set gavIncPathVS="%sVSPath%"

if not "%gavIncPathMy%"=="" (set gavIncPathAll=-I"%gavIncPathMy%")
if not %gavIncPathVS%=="" (set gavIncPathAll=%gavIncPathAll% -I%gavIncPathVS%)
echo Include pathes: %gavIncPathAll%


:: -------------------------------------- ::
::  Настройка путей к библиотечным (.lib) ::
::  файлам.   Каждый путь должен быть     ::
::         отдельной переменной !         ::
:: -------------------------------------- ::
set gavLibPathVS=%sVSPath%
if not "%gavLibPathVS%"=="" (set gavLibPathAll=/lib:"%gavLibPathVS%")
if not "%gavLibPathMy%"=="" (set gavLibPathAll=%gavLibPathAll% /lib:"%gavLibPathMy%")

echo Lib pathes: %gavLibPathAll%

:: -------------------------------------- ::
::      Файлы библиотеки run-time.        ::
:: При необходимости добавить сюда нужные ::
:: -------------------------------------- ::
:: set gavLibFilesCrt=user32.lib ole32.lib Gdi32.lib Ws2_32.lib Imm32.lib Comdlg32.lib Winspool.lib Advapi32.lib
::set gavLibFilesCrt=""
if not "%gavLibFilesCrt%"=="" (set gavLibFilesAll=%gavLibFilesCrt%)

echo Lib files: %gavLibFilesAll%


:: -------------------------------------- ::
::     Настройка режимов компиляции       ::
:: -------------------------------------- ::
if %iModeComp%==0 (
               set gavCompilFlags=%gavCompilFlags% /D:_RELEASE 
               set gavCompMode=/debug-
               set gavOptimize=/optimize+
              )

if %iModeComp%==1 (
               set gavCompilFlags=%gavCompilFlags% /D:_DEBUG 
               set gavCompMode=/debug+
               set gavOptimize=/optimize-
              ) 

:: -------------------------------------- ::
::    Настройка подсистемы приложения     ::
:: -------------------------------------- ::
if not %gavSubsystem%=="" (set gavLinkSubsys=/t:%gavSubsystem%)


:: -------------------------------------- ::
set gavDelExt=*.obj, *.exe, *.log, *.pdb
echo. 
echo Deleting old files: %gavDelExt% ...
echo. 
del %gavDelExt%
echo. 
echo ------------------
echo Compiling start...
echo ------------------
echo. 

echo on
"%sVSPathName%" %gavDefine% %gavCompilFlags% %gavCompMode% %gavOptimize% %gavLinkSubsys% /utf8output /fullpaths /platform:%gavPlatform% %gavLibPathAll% %gavLibFilesAll% %gavSrc%>__vc#_compile.log

@echo off
echo. 
echo ------------------
echo Compiling end...
echo ------------------
echo. 
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
:: -------------------------------------- ::
pause

Сборка cs-приложения из файлов солюшенов (sln) и проектов (csproj)

Код сценария vc#_sln_csproj_compile.cmd
:: Перед использованием сценария рекомендуется задать системную переменную sVSPathName,
:: указывающую путь к основному исполнимому файлу Visual Studio либо раскомментировать 
:: и отредактировать sVSPathName ниже в этом файле...
@echo off
cls

echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
:: -------------------------------------- ::
:: имя файла проекта (.csproj) или вокспейса (sln):
set sPrjFile=MyProject.csproj

:: -------------------------------------- ::
:: Режим компиляции: 0 - release, 1 - debug, 2 - release и debug:
set iMode=2

:: -------------------------------------- ::
:: Режим обработки файлов: 
::        0 - удаление промежуточных файлов, 
::        1 - перекомпиляция изменившихся фйлов,
::        2 - полная пересборка проекта (рекомендуется при iMode=2)
set iSubMode=2


:: -------------------------------------- ::
:: Имя конфигурации:
if %sPrjFile:.sln=% == %sPrjFile% (
   set sPrjName=%sPrjFile:.sln=%
  ) ELSE (
   set sPrjName=%sPrjFile:.csproj=%
  )

:: Имя конфигурации - для режима release: 
:: set sConfigNameRelease="Release|Win32"
set sConfigNameRelease="Release"
:: Имя конфигурации - для режима debug: 
:: set sConfigNameDebug="Debug|Win32"
set sConfigNameDebug="Debug"


:: -------------------------------------- ::
:: пути к Visual Studio:
set sVSPathName=%SYSTEMDRIVE%\Program Files (x86)\Microsoft Visual Studio\11.0\Common7\IDE\devenv.exe
:: set sVSPathName=%SYSTEMDRIVE%\Program Files\Microsoft Visual Studio 8\Common7\IDE\VCExpress.exe
:: set sVSPathName=%SYSTEMDRIVE%\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe

:: -------------------------------------- ::
:: Подрежим:

if %iSubMode%==0 (
               set iCompMode=/Clean
              )

if %iSubMode%==1 (
               set iCompMode=
              ) 

if %iSubMode%==2 (
               set iCompMode=/Rebuild
              ) 

:: -------------------------------------- ::
echo. 
echo ---------------------------------
echo [%sPrjName%]: compiling start...
echo ---------------------------------
echo. 
@echo off

if %iMode%==0 (
:: режим release: 
echo [%sPrjName%]: configuration mode:
echo     %sConfigNameRelease%
echo on
"%sVSPathName%" %sPrjFile% /Build %sConfigNameRelease% /Out __vc#_compile_release.log
)

@echo off
if %iMode%==1 (
:: режим debug: 
echo [%sPrjName%]: configuration mode:
echo     %sConfigNameDebug%
echo on
"%sVSPathName%" %sPrjFile% /Build %sConfigNameDebug%   /Out __vc#_compile_debug.log
)
 
@echo off
if %iMode%==2 (
:: режим release и debug: 
echo [%sPrjName%]: configuration modes: 
echo     %sConfigNameRelease%
echo     %sConfigNameDebug%
echo on
"%sVSPathName%" %sPrjFile% /Build %sConfigNameRelease% /Out __vc#_compile_release.log
"%sVSPathName%" %sPrjFile% /Build %sConfigNameDebug%   /Out __vc#_compile_debug.log
Rem /project lxDbLib.csproj /projectconfig Debug 
)


@echo off
echo. 
echo ---------------------------------
echo [%sPrjName%]: compiling end.
echo ---------------------------------
echo. 
echo -------------------------------------- 
echo ------ %date% [%time%] ------
echo -------------------------------------- 
echo ---------- .:: -=LEXX=- ::. ----------
echo -------------------------------------- 
:: -------------------------------------- ::
pause

На первый взгляд громоздкость данного кода, компенсируется простотой последующей работы в консоли. Всем приятного программирования!!!

C++ - Компиляция с помощью Visual C ++ (командной строки)

пример

Для программистов, поступающих из GCC или Clang в Visual Studio, или программистов, более удобных с командной строкой в ​​целом, вы можете использовать компилятор Visual C ++ из командной строки, а также из среды IDE.

Если вы хотите скомпилировать свой код из командной строки в Visual Studio, сначала необходимо настроить среду командной строки. Это можно сделать, открыв Visual Studio Command Prompt / Developer Command Prompt / x86 Native Tools Command Prompt / x64 Native Tools Command Prompt или аналогичная (как предоставляется вашей версией Visual Studio) или в командной строке, путем перехода к подкаталог VC каталога установки компилятора (обычно \Program Files (x86)\Microsoft Visual Studio x\VC , где x - номер версии (например, 10.0 для 2010 или 14.0 для 2015) и запуск командного файла VCVARSALL с помощью параметр командной строки, указанный здесь .

Обратите внимание, что в отличие от GCC, Visual Studio не предоставляет интерфейс для компоновщика ( link.exe ) через компилятор ( cl.exe ), но вместо этого предоставляет компоновщик как отдельную программу, которую компилятор вызывает при выходе. cl.exe и link.exe могут использоваться отдельно с разными файлами и параметрами, иначе cl может передаваться файлы и параметры для link если обе задачи выполняются вместе. Любые параметры привязки, указанные для cl будут переведены в параметры link , и любые файлы, не обработанные cl будут переданы непосредственно в link . Поскольку это в основном простое руководство по компиляции с командной строкой Visual Studio, аргументы для link не будут описаны в настоящее время; если вам нужен список, см. здесь .

Обратите внимание, что аргументы для cl чувствительны к регистру, а аргументы для link - нет.

[Следует иметь в виду, что в некоторых из следующих примеров при указании абсолютных имен пути используется переменная «текущий каталог» оболочки Windows, %cd% . Для тех, кто не знаком с этой переменной, он расширяется до текущего рабочего каталога. Из командной строки это будет каталог, в котором вы были, когда вы запускаете cl , и указывается в командной строке по умолчанию (если ваша командная строка - C:\src> , например, то %cd% - C:\src\ ).]


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

cl main.cpp
// Generates object file "main.obj".
// Performs linking with "main.obj".
// Generates executable "main.exe".

cl /Od main.cpp
// Same as above.
// "/Od" is the "Optimisation: disabled" option, and is the default when no /O is specified.

Предположим, что дополнительный файл-источник «niam.cpp» в том же каталоге использует следующее:

cl main.cpp niam.cpp
// Generates object files "main.obj" and "niam.obj".
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

Вы также можете использовать подстановочные знаки, как и следовало ожидать:

cl main.cpp src\*.cpp
// Generates object file "main.obj", plus one object file for each ".cpp" file in folder
//  "%cd%\src".
// Performs linking with "main.obj", and every additional object file generated.
// All object files will be in the current folder.
// Generates executable "main.exe".

Чтобы переименовать или переместить исполняемый файл, выполните одно из следующих действий:

cl /o name main.cpp
// Generates executable named "name.exe".

cl /o folder\ main.cpp
// Generates executable named "main.exe", in folder "%cd%\folder".

cl /o folder\name main.cpp
// Generates executable named "name.exe", in folder "%cd%\folder".

cl /Fename main.cpp
// Same as "/o name".

cl /Fefolder\ main.cpp
// Same as "/o folder\".

cl /Fefolder\name main.cpp
// Same as "/o folder\name".

Оба параметра /o и /Fe передают свой параметр (назовем его o-param ), чтобы link как /OUT:o-param , добавив соответствующее расширение (обычно .exe или .dll ) в «имя» o-param s по мере необходимости. Хотя оба /o и /Fe , насколько мне известно, идентичны по функциональности, последний предпочтительнее для Visual Studio. /o отмечен как устаревший и, как представляется, в основном предоставляется программистам, более знакомым с GCC или Clang.

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


Аналогично, для создания оптимизированного исполняемого файла (для использования в производстве) используйте:

cl /O1 main.cpp
// Optimise for executable size.  Produces small programs, at the possible expense of slower
//  execution.

cl /O2 main.cpp
// Optimise for execution speed.  Produces fast programs, at the possible expense of larger
//  file size.

cl /GL main.cpp other.cpp
// Generates special object files used for whole-program optimisation, which allows CL to
//  take every module (translation unit) into consideration during optimisation.
// Passes the option "/LTCG" (Link-Time Code Generation) to LINK, telling it to call CL during
//  the linking phase to perform additional optimisations.  If linking is not performed at this
//  time, the generated object files should be linked with "/LTCG".
// Can be used with other CL optimisation options.

Наконец, чтобы создать оптимизированный исполняемый файл для конкретной платформы (для использования на производстве на машине с указанной архитектурой), выберите соответствующую командную строку или параметр VCVARSALL для целевой платформы. link должна обнаружить желаемую платформу из объектных файлов; если нет, используйте параметр /MACHINE чтобы явно указать целевую платформу.

// If compiling for x64, and LINK doesn't automatically detect target platform:
cl main.cpp /link /machine:X64

Любое из вышеперечисленного даст исполняемый файл с именем, указанным /o или /Fe , или если ни один из них не указан, с именем, идентичным первому источнику или объекту, указанному компилятору.

cl a.cpp b.cpp c.cpp
// Generates "a.exe".

cl d.obj a.cpp q.cpp
// Generates "d.exe".

cl y.lib n.cpp o.obj
// Generates "n.exe".

cl /o yo zp.obj pz.cpp
// Generates "yo.exe".

Чтобы скомпилировать файл (ы) без ссылки, используйте:

cl /c main.cpp
// Generates object file "main.obj".

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

cl main.obj niam.cpp
// Generates object file "niam.obj".
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

link main.obj niam.obj
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

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

cl /EHsc main.cpp
// "/EHsc" specifies that only standard C++ ("synchronous") exceptions will be caught,
//  and `extern "C"` functions will not throw exceptions.
// This is recommended when writing portable, platform-independent code.

cl /clr main.cpp
// "/clr" specifies that the code should be compiled to use the common language runtime,
//  the .NET Framework's virtual machine.
// Enables the use of Microsoft's C++/CLI language in addition to standard ("native") C++,
//  and creates an executable that requires .NET to run.

cl /Za main.cpp
// "/Za" specifies that Microsoft extensions should be disabled, and code should be
//  compiled strictly according to ISO C++ specifications.
// This is recommended for guaranteeing portability.

cl /Zi main.cpp
// "/Zi" generates a program database (PDB) file for use when debugging a program, without
//  affecting optimisation specifications, and passes the option "/DEBUG" to LINK.

cl /LD dll.cpp
// "/LD" tells CL to configure LINK to generate a DLL instead of an executable.
// LINK will output a DLL, in addition to an LIB and EXP file for use when linking.
// To use the DLL in other programs, pass its associated LIB to CL or LINK when compiling those
//  programs.

cl main.cpp /link /LINKER_OPTION
// "/link" passes everything following it directly to LINK, without parsing it in any way.
// Replace "/LINKER_OPTION" with any desired LINK option(s).

Для тех, кто более знаком с системами * nix и / или GCC / Clang, cl , link и другими инструментами командной строки Visual Studio, могут принимать параметры, указанные с помощью дефиса (например, -c ), вместо косой черты (например, /c ). Кроме того, Windows распознает либо косую черту, либо обратную косую черту как допустимый разделитель путей, поэтому можно использовать также пути в стиле nix. Это упрощает преобразование простых команд компилятора из g++ или clang++ в cl , или наоборот, с минимальными изменениями.

g++ -o app src/main.cpp
cl  -o app src/main.cpp

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

Если вам нужны специальные языковые функции для вашего кода, требуется определенная версия MSVC. Из Visual C ++ 2015 Update 3 можно выбрать версию стандарта для компиляции с помощью флага /std . Возможные значения: /std:c++14 и /std:c++latest ( /std:c++17 скоро появится).

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




Какой выбрать C++ компилятор под Windows? — Хабр Q&A

Очень часто разработчики под windows с самого начала начинают работать с visual studio и с его немного несовместимым компилятором и std библиотеками, из-за чего последующие попытки собирать код из стандартного окружения порождают кучу работы, на нее забивают и продолжают сидеть на майкрософтовском.
Самостоятельная настройка окружения для сборки под windows тут возможна (без загрузки visual studio) но поверьте, вам не захочется вручную загружать и настраивать сотни пакетов, никто этой фигней не мается. Ставят visual studio с интерфейсом, а там никто не мешает использовать командную строку.

В общем случае, с вероятностью 99.9999999999%, вам будет НЕДОСТАТОЧНО только компилятора, вам нужны еще и библиотеки, настроенные на ваше окружение. Т.е. в зависимости от того под какую архитектуру и операционную систему вы собираете библиотеки/бинарники, и будет соответствующий ответ.

Наиболее полно готовый и почти настроенный тулчейн (почти и наверняка это будет gnu compiler, но ничто не помешает использовать clang) можно найти в linux операционных системах, т.е настроив кросскомпиляцию из linux окружения можно будет собирать все, кроме наверное macos (ну там свои заморочки и это не невозможно).

Только там, одинаково просто, можно будет собирать как windows приложения так и arduino скетчи.

p.s. для настройки linux дистрибутива интернет вам понадобится только что для поиска документации, репозитории (тех же debian/ubuntu) можно приобрести на компакт дисках или сделать свой offline инсталятор.

p.p.s. вы можете попытаться использовать windows 10 (не домашние) подсистему linux, установив в нее ту же ubuntu, и без каких либо накладных расходов (это не виртуалка, это скорее wine наоборот) работать

Ближайший аналог удобного окружения но под windows это mingw (много рукошевелений) и cygwin, последняя так вообще копирует linux, но там свои заморочки, например файловые пути в итоговом приложении для совместимости будут вида /cygdrive/c/...., плюс совместимость dll своя, ни с чем не совместимая.

Онлайн-компилятор для Си: выбираем лучший компилятор C

C___Deep_4.3_site-5020-795e6f.png

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

В этой статье вы найдете подборку лучших онлайн-компиляторов. Почти все они универсальны. Многие поддерживают не только язык программирования C, но и массу других языков. Итак, встречайте лучшие компиляторы для online-использования!

IdeOne

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

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

Koding

В принципе, Koding.com это не online-компилятор в привычном смысле. Он позволяет создавать в облаке полноценные виртуальные машины под управлением Ubuntu, а на них уже можно делать всё, что заблагорассудится, включая компилирование кода. Есть панель управления своим сервером и окошко терминала. Доступна удобная IDE в интерфейсе.

JDoodle

Это приложение поддерживает много языков, среди которых есть те, которые вы не найдёте во многих других инструментах для компиляции. Приятная особенность JDoodle — возможность совместной работы с другом или с коллегой. Для этого достаточно отправить ссылку на текущую сессию, после чего можно разрабатывать приложения с удвоенной скоростью!

CodePad

Говорят, что быстрее и лучше работается с минималистичным сервисом. CodePad — именно таковым и является. Он простой и абсолютно нересурсоёмкий, поэтому сайт будет хорошо работать даже при медленной скорости вашего интернета. Вдобавок ко всему, предусмотрены такие «плюшки», как интеграция с Vim либо Emacs и автоподключение стандартных заголовков.

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

GCC GodBolt

GCC GodBolt — популярный интерактивный онлайн-compiler исключительно для С++. Имеет простейший интерфейс и много настроек, включая опции, регулируемые с помощью ключей. Доступен выбор среди разных версий. Интересная особенность компилятора — возможность моментального перевода кода программы непосредственно на язык ассемблера.

А какой компилятор используете вы? Пишите в комментариях!

-platform (параметры компилятора C#) | Microsoft Docs

  • Чтение занимает 2 мин

В этой статье

Указывает, в какой версии среды CLR может запускаться сборка.Specifies which version of the Common Language Runtime (CLR) can run the assembly.

СинтаксисSyntax

-platform:string

ПараметрыParameters

string
anycpu (по умолчанию), anycpu32bitpreferred, ARM, x64, x86 или Itanium.anycpu (default), anycpu32bitpreferred, ARM, x64, x86, or Itanium.

RemarksRemarks

  • anycpu (по умолчанию) позволяет компилировать сборку для запуска на любой платформе.anycpu (default) compiles your assembly to run on any platform. Если возможно, приложение выполняется как 64-разрядный процесс, а если доступен только 32-разрядный режим, переключается на него.Your application runs as a 64-bit process whenever possible and falls back to 32-bit when only that mode is available.

  • anycpu32bitpreferred (по умолчанию) позволяет компилировать сборку для запуска на любой платформе.anycpu32bitpreferred compiles your assembly to run on any platform. Приложение выполняется в 32-разрядном режиме в системах, поддерживающих и 64-разрядные, и 32-разрядные приложения.Your application runs in 32-bit mode on systems that support both 64-bit and 32-bit applications. Можно задать этот параметр только для проектов, предназначенных для среды .NET Framework 4.5.You can specify this option only for projects that target the .NET Framework 4.5.

  • ARM компилирует сборку для выполнения на компьютере с процессором Advanced RISC Machine (ARM).ARM compiles your assembly to run on a computer that has an Advanced RISC Machine (ARM) processor.

  • ARM64 компилирует сборку для выполнения 64-разрядной средой CLR на компьютере с процессором Advanced RISC Machine (ARM) с поддержкой набора инструкций А64.ARM64 compiles your assembly to run by the 64-bit CLR on a computer that has an Advanced RISC Machine (ARM) processor that supports the A64 instruction set.

  • x64 компилирует сборку для запуска в 64-разрядной среде CLR на компьютере, поддерживающем набор инструкций AMD64 или EM64T.x64 compiles your assembly to be run by the 64-bit CLR on a computer that supports the AMD64 or EM64T instruction set.

  • x86 компилирует сборку для запуска в 32-разрядной среде CLR с архитектурой x86.x86 compiles your assembly to be run by the 32-bit, x86-compatible CLR.

  • Itanium компилирует сборку для запуска в 64-разрядной среде CLR на компьютере с процессором Itanium.Itanium compiles your assembly to be run by the 64-bit CLR on a computer with an Itanium processor.

В 64-разрядной ОС Windows:On a 64-bit Windows operating system:

  • Сборки, скомпилированные с параметром -platform:x86, будут выполняться в 32-разрядной среде CLR с WOW64.Assemblies compiled with -platform:x86 execute on the 32-bit CLR running under WOW64.

  • Библиотека DLL, скомпилированная с использованием параметра -platform:anycpu, выполняется в той же среде CLR, в которую загружается процесс.A DLL compiled with the -platform:anycpu executes on the same CLR as the process into which it is loaded.

  • Исполняемые файлы, скомпилированные с использованием параметра -platform:anycpu, выполняются в 64-разрядной среде CLR.Executables that are compiled with the -platform:anycpu execute on the 64-bit CLR.

  • Исполняемые файлы, скомпилированные с использованием параметра -platform:anycpu32bitpreferred, выполняются в 32-разрядной среде CLR.Executables compiled with -platform:anycpu32bitpreferred execute on the 32-bit CLR.

Параметр anycpu32bitpreferred допустим только для исполняемых файлов (EXE-файлов), и для него необходима среда .NET Framework 4.5.The anycpu32bitpreferred setting is valid only for executable (.EXE) files, and it requires the .NET Framework 4.5.

Дополнительные сведения о разработке приложений для запуска в 64-разрядной операционной системе Windows см. в разделе 64-разрядные приложения.For more information about developing an application to run on a Windows 64-bit operating system, see 64-bit Applications.

Установка данного параметра компилятора в среде разработки Visual StudioTo set this compiler option in the Visual Studio development environment

  1. Откройте страницу свойств для проекта.Open the Properties page for the project.

  2. Щелкните страницу свойств Сборка.Click the Build property page.

  3. Измените значение свойства Целевая платформа, а для проектов, предназначенных для среды .NET Framework 4.5, установите или снимите флажок Предпочитать 32-разрядную.Modify the Platform target property and, for projects that target the .NET Framework 4.5, select or clear the Prefer 32-bit check box.

Примечание

Параметр -platform недоступен в среде разработки в Visual C# Express.-platform is not available in the development environment in Visual C# Express.

Сведения об установке этого параметра компилятора программными средствами см. в разделе PlatformTarget.For information on how to set this compiler option programmatically, see PlatformTarget.

ПримерExample

В следующем примере показано использование параметра -platform, чтобы указать, что приложение должно выполняться в 64-разрядной среде CLR в 64-разрядной операционной системой Windows.The following example shows how to use the -platform option to specify that the application should be run by the 64-bit CLR on a 64-bit Windows operating system.

csc -platform:anycpu filename.cs

См. также разделSee also

Компиляторы

- Учебники по C ++

Основные инструменты, необходимые для выполнения этих руководств, - это компьютер и набор инструментов компилятора, способный компилировать код C ++ и создавать программы для работы на нем.

C ++ - это язык, который сильно развился за эти годы, и в этих руководствах объясняются многие функции, недавно добавленные в язык. Следовательно, чтобы правильно следовать руководствам, необходим последний компилятор. Он должен поддерживать (хотя бы частично) функции, представленные стандартом 2011 года.

Многие поставщики компиляторов поддерживают новые функции в разной степени. Внизу этой страницы указаны некоторые компиляторы, которые, как известно, поддерживают необходимые функции. Некоторые из них бесплатны!

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


Что такое компилятор?

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

Одна инструкция для компьютера может выглядеть так:


Программа на машинном языке конкретного компьютера, которая позволяет пользователю вводить два числа, складывать два числа и отображать итоговую сумму, может включать следующие инструкции машинного кода:
00000 10011110
00001 11110100
00010 10011110
00011 11010100
00100 10111111
00101 00000000

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

Это часть кода, написанная на C ++, которая выполняет ту же самую цель:

  1 
2
3
4
5
6
7
   int  a, b, sum;
     
cin >> a;
cin >> b;
             
сумма = а + б;
cout << сумма << endl;  

Даже если вы не совсем понимаете приведенный выше код, вы должны понимать, насколько проще будет программировать на языке C ++, а не на машинном языке.

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

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


Консольные программы

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

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

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

Самый простой способ для новичков компилировать программы на C ++ - использовать интегрированную среду разработки (IDE). IDE обычно объединяет несколько инструментов разработки, включая текстовый редактор и инструменты для компиляции программ прямо из него.

Здесь у вас есть инструкции по компиляции и запуску консольных программ с использованием различных бесплатных интегрированных интерфейсов разработки (IDE):


Если у вас есть среда Linux или Mac с функциями разработки, вы сможете скомпилировать любой из примеров непосредственно из терминала, просто включив флаги C ++ 11 в команду для компилятора:
Compiler Платформа Command
GCC Linux и другие... g ++ -std = c ++ 0x example.cpp -o example_program
Clang OS X, среди прочего ... clang ++ -std = c ++ 11 -stdlib = libc ++ example.cpp -o example_program
,

Совместная компиляция файлов C и C ++ с использованием GCC

Переполнение стека
  1. Товары
  2. Клиенты
  3. Случаи использования
  1. Переполнение стека Общественные вопросы и ответы
  2. Команды Частные вопросы и ответы для вашей команды
  3. предприятие Частные вопросы и ответы для вашего предприятия
  4. работы Программирование и связанные с ним возможности технической карьеры
  5. Талант Нанять технических талантов
  6. реклама Обратитесь к разработчикам по всему миру
,

Компиляция и компоновка в C ++

Когда вы пишете программу на C ++, следующим шагом является ее компиляция перед ее запуском. Компиляция - это процесс, который преобразует программу, написанную на понятном человеку языке, таком как C, C ++ и т. Д., В машинный код, непосредственно понимаемый центральным процессором. Создание исполняемого файла из исходного файла состоит из множества этапов. Этапы включают предварительную обработку, компиляцию и компоновку в C ++. Это означает, что даже если программа будет скомпилирована, она может не работать, поскольку на этапе компоновки могут возникнуть ошибки.Следовательно, большинство IDE (интегрированная среда разработки), такие как Eclipse, Geany и т. Д., Рассматривают термин сборка для преобразования файла исходного кода в исполняемый файл.

Теперь, как вы компилируете определенную программу, это зависит от операционной системы и компилятора. В наши дни компиляторы запускаются из IDE (интегрированной среды разработки), которая содержит инструменты для построения и анализа. Вам просто нужно щелкнуть меню, чтобы скомпилировать программу, а затем запустить ее. Но на самом деле весь процесс происходит в разные фазы.Вот где приходит компиляция и компоновка в C ++.

Предварительная обработка

На этом этапе препроцессор изменяет progrPreprocessingam в соответствии с указанными директивами (начинается со знака #). Препроцессор C ++ берет программу и работает с директивами # include, и в результате получается программа на чистом C ++. Например, в программе на C ++ #include сообщит препроцессору, что нужно прочитать все содержимое файла заголовка iostream, включить его в программу и сгенерировать отдельный файл программы на C ++.C ++ поддерживает множество директив препроцессора, например #include, #define, #if, #else и т. Д.

Компиляция

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

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

Но вы по-прежнему не можете запускать эти объектные файлы, пока не конвертируете их в исполняемый файл, теперь здесь вступает в действие компоновщик, который связывает все объектные файлы для создания единого исполняемого файла.

Связывание

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

Вложения: [Selection_101.png] [Selection_103.png]

,

Компиляция C и C ++ - 2 ответа

Переполнение стека
  1. Товары
  2. Клиенты
  3. Случаи использования
  1. Переполнение стека Общественные вопросы и ответы
  2. Команды Частные вопросы и ответы для вашей команды
  3. предприятие Частные вопросы и ответы для вашего предприятия
  4. работы Программирование и связанные с ним возможности технической карьеры
  5. Талант Нанять технических талантов
  6. реклама Обратитесь к разработчикам по всему миру
,

Добавить комментарий

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