We usually use a compiler with a graphical user interface to compile our C program. This can also be done by using cmd. The command prompt has a set of steps we need to perform in order to execute our program without using a GUI compiler. In this article, we will understand how to compile and Run a C program in the command prompt.
So let us get with this article on how to compile C progam in command prompt,
How to Compile and Run C Program in Command Prompt?
STEP 1: Check for Compiler
Run the command ‘gcc -v’ to check if you have a compiler installed. If not you need to download a gcc compiler and install it. You can search for cmd in your windows system to open the command prompt.
STEP 2: Create the Program
Create a c program and store it in your system. I have written a program to find the Armstrong Number and store it in the directory user. We would be using following code.
#include <stdio.h>
int main()
{
int num, original, rem, sum = 0;
printf("Enter a three digit Number: ");
scanf("%d", &num);
original = num;
while (original != 0)
{
rem = original%10;
sum =sum + rem*rem*rem;
original =original/ 10;
}
if(sum == num)
printf("%d is an Armstrong number.",num);
else
printf("%d is not an Armstrong number.",num);
return 0;
}
STEP 3: Change the Directory
Change the working directory to where you have your C program. You can do that by using the command ‘cd’, which changes the directory. We need to pass the name of the directory in which the program is stored.
Example: >cd Desktop
Our program is already in the user directory so, we don’t need to change it.
STEP 4: Compile the program
The next step is to compile the program. To do this we need to use the command gcc followed by the name of the program we are going to execute. In our case, we will use Armstrong.c.
After this, an executable file will be created in the directory that your c file exists in. Eg: Armstrong.exe
STEP 5: Run the Program
In the next step, we can run the program. This is done by simply giving the name of the executable file without any extension. On giving this we will get an output. Here, our Armstrong code is executed and we got output for this code.
But What Happens Inside the Compilation Process?
The term “compile” refers to the procedure by which C language source code is translated into machine code. C is a middle-level programming language, so we need a compiler to turn it into machine code before we can run it.
During the compilation process, the C program goes through the following steps:
How to Run C program in Terminal?
If running a C program in a terminal is what you want to do, Here’s what you should do:
- Write Your C Program: You need to prepare a file containing your C code, hello.c for example.
- Open Terminal: Launch the terminal program you are using (Terminal as an example on macOS or Linux and Command Prompt and Powershell on Windows or Cygwin or WSL if you are using Windows).
- Go to the Program Folder: To do this, type cd followed by the path leading to the folder containing your C file i.e. cd path/to/your/folder.
- You can convert the C Program to a Runnable File: Transform your code so that it becomes executable by using programs such as gcc. To change hello.c into a program called hello, type gcc -o hello hello.c This means that one can also replace it with clang as follows: clang -o hello hello.c.
- Start Running It: Once it is in a state whereby it can be executed, you may commence running this system. If using Linux or macOS, type ./hello to execute doing so.
To compile and run your C program from the terminal without any problems, simply type hello.exe on a regular command prompt in a Windows environment or in a unix-like one, use the command ./hello.exe.
Here you find lots of online compilers and integrated development environments; these are the best.
1. Replit
Go to replit.com
Start a new Repl and choose the language, C.
Write your code and just click the Run button.
2. OnlineGDB
Go to onlinegdb.com
Write your C code in the editor.
Click Run – to compile and execute the code.
3. JDoodle
Go to jdoodle.com
Choose language C, input your code and click the Execute button.
4. Compiler Explorer
Go to godbolt.com.
Select C and write your code below. This site primarily displays assembly output, but you are able to run code –
go through the exercise
5. TutorialsPoint
Open your browser to tutorialspoint.com
Write your C code below and use the “Compile & Execute” button
Practice the Steps
Open your browser to the site you selected
Set your language to programming C
Write below or copy and past your C code here
Ensure that the compile and run button is pressed to compile and run your program
These sites allow you to practice C code without having to make a whole local configuration of your own.
To execute a program in Command Prompt (CMD) of Windows:
1. Open cmd. Press Windows + R, type in cmd, and hit Enter.
2. Open a Program Directory. You can use the following cd command to navigate to the folder where the program meant to run is. For example:
cd C:pathtoyourprogram
(executable) or programmable scripts then you can just type name of your script and press Enter
program.exe
4. Script or Batch File
execute here you may have a script (eg. .bat or .py file) that also needs invoked this way
execute a batch file here:
script.bat
execute a python script file:
python script.py
Example
Goto directory:
cd C:UsersYourNameDocuments
Now execute the program:
myprogram.exe
More Help
To list contents of a directory use dir
To launch a program with administrator privilege, right-click the CMD icon and select Run as administrator
And that’s all there is to it! You’ve just executed a program via the Command Prompt.
To execute a program in Command Prompt (CMD) of Windows:
1. Open cmd. Press Windows + R, type in cmd, and hit Enter.
2. Open a Program Directory. You can use the following cd command to navigate to the folder where the program meant to run is. For example:
cd C:pathtoyourprogram
(executable) or programmable scripts then you can just type name of your script and press Enter
program.exe
4. Script or Batch File
execute here you may have a script (eg. .bat or .py file) that also needs invoked this way
execute a batch file here:
script.bat
execute a python script file:
python script.py
Example
Goto directory:
cd C:UsersYourNameDocuments
Now execute the program:
myprogram.exe
More Help
To list contents of a directory use dir
To launch a program with administrator privilege, right-click the CMD icon and select Run as administrator
And that’s all there is to it! You’ve just executed a program via the Command Prompt!.
1. Write Your C Program
Create a text file with a text editor.
For example with nano:
nano myprogram.c
2. Compile the C Program
Compile your program using gcc:
gcc myprogram.c -o my program
3. Run the Executable
Run your compiled program using:
./myprogram
Example Steps
Create a text file:
#include <stdio.h>
int main() {
printf(“Hello, World!
“);
return 0;
}
Save this file as hello.c.
Compile:
gcc hello.c -o hello
Run.
Here is how you run your C program inside an Ubuntu Terminal shell.
Compile: gcc filename.c -o outputname
Run: ./outputname.
1. Write Your C++ Program
Create a file with a .cpp extension of you favorite
text editor, for example:
nano myprogram.cpp
2 Compile the C++ Program
Then compile the C++ source file some file.cpp using
g++ GNU C++ Compiler:
g++ myprogram.cpp -o myprogram
3 Run the Executable
Execute your compile program with:
./myprogram
Detailed Example
Let’s create a simple C++ source file:
#include <iostream>
int main() {
std::cout << “Hello, World!” << std::endl;
return 0;
}
Save this
Edit: Create new file with .cpp as extension
Compile: g++ filename.cpp -o outputname
Run: ./outputname
Doesn’t it look kind of easy to edit, compile, and run C++ code in Linux with just a little help from these steps?
FAQs
1.How do I compile the c program in terminal?
you can use the gcc command followed by the name of your source file. For instance, let’s consider a file named myprogram.c which needs to be compiled using gcc command as shown below: gcc myprogram.c -o myprogram. In plain terms, gcc is an acronym for GNU Compiler Collection whose work encompasses translating C code into assembly and finally binary code that computer hardware can execute properly under Unix-like operating systems. If these terms seem strange then consider this; “myprogram.c” stands for your source file or rather what contains the instructions/syntaxes together with “-o myprogram” denoting the output file name where myprogram will be an ultimate “executable” binary file.
2. How do I execute a C code in Linux online?
Repl.it, JDoodle and others are the examples of online platforms where someone may access a Linux runtime environment in order to compile and run C programs.
3. What happens when my C program takes advantage of libraries using <math.h>?
If you utilize standard libraries as <math.h> your C program will not require any special flags for compilation.If you include it right at the beginning through(#include <math.h>). Compiling is typically the same:gcc myprogram.c -o myprogram.
4. Is it possible to compile and run a C program without saving it as a file?
No, you have to save the C program as a .c file first so that you may compile and run it. The name of the file must be specified so that the source code for the C programming language can be read and processed.
With this we come to the end of this blog on ‘How To Compile C program in Command Prompt’. I hope you found this informative and helpful, stay tuned for more tutorials on similar topics.You may also checkout our training program to get in-depth knowledge on jQuery along with its various applications, you can enroll here for live online training with 24/7 support and lifetime access.
Got a question for us? Mention them in the comments section of this blog and we will get back to you.
Last Updated :
07 Apr, 2025
To efficiently compile and run C programs, users typically utilize a compiler or the built-in terminal. The command prompt (CMD) on Windows can be employed to process C programs and generate the desired outputs. To create an executable C program, users must compile their C code using the system terminal.
This article will discuss how to compile and run a C program from the Windows command prompt using MinGW, a user-friendly version of the GCC compiler.
How to Compile and Run C Program in Terminal
Users need to type a few levels of commands into the command prompt or in-build terminal to run the C program without a GUI compiler by following the system configuration. The process of converting C language source code into a machine-code binary system is referred to as «compile» to process «run». Because C is a middle-level programming language and not portable, it must first be translated into machine code using a compiler to be executed and run within the environment. We need to follow the below-mentioned steps to compile and run the C program in the in-build system terminal —
Step 1: Download or Install MinGW officially
First, we must install a C compiler in our system to execute and compile the C code into a binary configuration. For Windows, MinGW is the efficient option for the initial process to implement the programs.
- Install MinGW from the official website > Click on the Downloaded File from the page > Follow the on-screen instructions to prepare the installation process and model functions efficiently.
- Go to the MinGW installation manager window > click on the pop-up button > See the packages required to compile C programs for executable output system.
- Check on the driver boxes that show «mingw32-base» and «mingw-gcc-g++» > Select Continue
- Click on Installation menu to install > Select Apply changes option for packages > Click on Apply button
Step 2: Add the compiler’s Path to the system environment via Windows
This is the easiest step to add the compiler’s path to the internal system environment variables and compile to run the C program. By this step, we can run the compiler from the command prompt and we won’t have to enter the full path environment to the GCC program in the system configuration to compile the C program.
- Press the Windows button from the keyboard > Type environment or environment variables > Click on the search result which shows Edit the system environment variables > Process to execute
- Click on the Environment Variables button > Select the path option under the «System variables» section > Select the Edit button
- Click on New > Type «C:\MinGW\bin» > Click Ok (for 3 times) > Go to Homepage
.png)
Step 3: Open the cmd environment or Command Prompt window
Now, open a Command Prompt window and run as administrator to compile and run the C program.
- Press the Windows button from the keyboard > Type cmd or Command Prompt
- Right-click on the Command Prompt from the home screen > Select Run as Administrator option > Run «gcc — version» at the prompt option to execute
Step 4: Implement the ‘cd’ Command to run and execute
Now, we need to use the cd command to go to the system directory and compile the code where the pre-structured C program is saved individually.
- Go to «C:\MyPrograms» option > Type «cd C:\MyPrograms» to put the value > Click on the Enter button to execute.
Step 5: Run the ‘gcc’ command to file management
After implementing the above steps, we can run the GCC command to compile the C program in our system for the further process. We use the structured syntax «gcc filename. c -o filename.exe» which compiles and makes the programs executable in the terminal.
- Remember the File name which contains the C code > Replace «filename. the c» with the internal File name
- Compiled structured program name which ends with «.exe» file > file shows a flag «-o» which specifies the output file config.
Step 6: Run the C program and see the output
It’s the final step to compile and run our C program efficiently and see the output in the terminal.
- Type the new program name > Click on the Enter button
C
#include <stdio.h> int main() { int n = 153; int temp = n; int p = 0; while (n > 0) { int rem = n % 10; p = (p) + (rem * rem * rem); n = n / 10; } // Condition to check whether the // value of P equals to user input // or not. if (temp == p) { printf("It is Armstrong No."); } else { printf("It is not an Armstrong No."); } return 0; }
Output
It is Armstrong No.
Conclusion
C programming language is a middle-level procedural programming language. It offers high-level internal system capabilities like functions and structures in addition to low-level features like memory address access features. The process of compiling and executing a C program on the terminal is simple after implementing the proper steps. Understanding this initial method or steps is essential to writing and developing C programs that will help all the possibilities of design and run them more efficiently in any system.
Also Read
- How To Compile And Run a C/C++ Code In Linux
- How to Compile a C++ Program Using GCC
- How to Compile and Run C/C++/Java Programs in Linux
Download Article
Turn your C files into programs you can run
Download Article
- Installing Visual Studio
- Writing the Program
- Compiling and Running
|
|
If you’ve written or downloaded some C code on your Windows PC, you’ll need to compile the code to turn it into a program you can run. You can easily do so using the developer command prompt for Visual Studio, which is free to download for personal use. The developer command prompt works just like the standard command prompt, but has extra developer commands, such as the ability to compile and run C programs. This wikiHow article teaches you how to compile and run C programs using the developer command line.
Quick Steps
- Download and install Visual Studio Desktop Development with C++
- Write your C program using a text program such as Notepad.
- Save the file as a “.c” file.
- Open the Developer Command Prompt as an administrator.
- Type “cl” followed by the filename of your C program and press Enter.
- Type the executable name and press Enter to run the program.
-
Go to https://visualstudio.microsoft.com/downloads in a web browser. Visual Studio not only contains an IDE that allows you to write and compile C programs, but it also contains a Developer Command Prompt that allows you to compile C programs. The Developer Command Prompt works just like the regular Windows Command Prompt, except it has environment variables that allow you to run commands to compile C programs.
-
If you are just learning how to write a program or using it for personal use, click Free Download below “Community.” This is the free version of Visual Studio. If you are working for a small team, you can click Free Trial below “Professional.” If you work for a large company, you can click Free Trial below “Enterprise.” This will download the Visual Studio installer.
Advertisement
-
You can find it in your downloads folder by default. This will launch the Visual Studio installer. Once the installer launches, it will inform you that you need to set up a few things to configure the installation. Click Continue to proceed.
-
Installing Desktop Development with C++ will install the components needed to write and compile C++ and C programs. You can also install any other languages you are interested in working on (i.e., Python development).[1]
- Depending on what you are interested in working on, you may want to install other C++ development workloads, such as Mobile development with C++, Game development with C++, or WinUI application development.
- Additionally, you can click the Individual Components tab at the top and check individual boxes next to the tools you want to install, such as C++/CLI support.
-
This will begin installing the development workloads you selected. This may take a while.
Advertisement
-
You can use a basic text program such as Notepad to write basic C programs. Notepad comes pre-installed on Windows. You can find Notepad in the Windows Start menu.
- Alternatively, you can use a program such as Notepad++ or an integrated development environment such as Eclipse to write C programs. These programs have tools to assist you with writing code.
-
You can write your entire C program in Notepad. If you have no programming experience, you may want to take some time to learn. You can find plenty of tutorials online with examples of basic C programs.[2]
-
Use the following steps to do so:
- Click File in the menu bar at the top.
- Click Save as in the drop-down menu.
- Select All files next to “Save as type.”
- Enter a filename for the file.
- Add the extension “.c” at the end of the filename.
- Click Save.
Advertisement
-
Visual Studio installs a Developer Command Prompt that works just like CMD, but allows you to execute developer commands. Use the following steps to open the Developer Command Prompt.
- Click the Windows Start button.
- Type developer command prompt
- Right-click Developer Command Prompt for VS.
- Click Run as administrator.
-
You can change directories using the “CD” command. Type cd followed by the path to the location of your C program and press Enter. For example; cd C:\Users\[username]\Documents\C Programs\Hello.
-
For example, cl hello.c. This will compile the program and output an executable (.exe) file.
- You can compile more than one file at a time. To do so, enter each filename after the “cl” command separated by a space. For example, cl file1.c file2.c file3.c
- If you want to change the name of the executable file, type /out: followed by the name you want to give the executable file at the end of the command. For example, cl hello.c /out:helloworld.exe
-
To run the executable file in the command line, simply type the filename of the executable file (i.e., “helloworld.exe”) and press Enter. This will run the executable file.
Advertisement
Ask a Question
200 characters left
Include your email address to get a message when this question is answered.
Submit
Advertisement
Thanks for submitting a tip for review!
About This Article
Thanks to all authors for creating a page that has been read 326,797 times.
Is this article up to date?
Частенько нет необходимости запускать тяжеловесную 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
На первый взгляд громоздкость данного кода, компенсируется простотой последующей работы в консоли. Всем приятного программирования!!!
Окружение: операционная система «Windows 10».
Ранее я написал ряд постов, посвященных изучению языка программирования C++ по учебнику Роберта Лафоре. В тех статьях я разбирал примеры и упражнения и выполнял их в интегрированной среде разработки (IDE), в качестве которой использовал «Microsoft Visual Studio». В то время я использовал бесплатную версию этой среды «Visual Studio Community 2017», а сейчас использую «Visual Studio Community 2022» (версия 17.5.3 от 21 марта, самая свежая на сегодня).
Начинающим изучать язык программирования C++ вполне себе можно стартовать с установки этой среды и работе в ней. (Следует иметь в виду, что у среды «Microsoft Visual Studio» есть ряд отличных альтернатив, я вовсе не хочу сказать, что изучение языка C++ в среде «Microsoft Visual Studio» — это единственный путь для начинающего.) У этой среды есть как свои достоинства, так и свои недостатки. Самый большой ее недостаток, на мой взгляд, в том, что она очень большая и неповоротливая, требует достаточно мощного компьютера. При этом бо́льшая часть инструментов этой среды начинающими не используется.
Одной из хороших альтернатив работе в интегрированной среде разработки для начинающего является работа с компилятором языка C++ из командной строки. Этот способ подходит тем, у кого слабый компьютер, который не тянет работу с большой IDE вроде «Microsoft Visual Studio». Бывают и другие причины для выбора работы из командной строки. (В принципе, на мой взгляд, начинающему изучать язык программирования C++ имеет смысл поработать и в IDE, и научиться работать из командной строки.)
Так же, как в случае работы в интегрированной среде разработки, для работы с кодом программ на языке C++ из командной строки есть ряд альтернатив, но в этом посте я буду описывать работу с компилятором «Microsoft Visual C++», который больше известен под аббревиатурой «MSVC».
Microsoft C++ Build Tools
Для работы из командной строки компания «Microsoft» предлагает набор инструментов (программ и скриптов) для сборки (Build Tools), который называется «Microsoft C++ Build Tools» (он же «Visual Studio Build Tools» или «Build Tools for Visual Studio» и тому подобное). Этот набор инструментов включает в том числе упомянутый выше компилятор «MSVC» и другие нужные для сборки кода на языке C++ инструменты.
В общем, набор инструментов «Microsoft C++ Build Tools» можно загрузить отдельно, либо его же можно загрузить в составе дистрибутива среды «Microsoft Visual Studio», если при установке этой среды выбрать рабочую нагрузку (workload), предназначенную для работы с кодом на языке C++ (например, «Desktop development with C++» или что-то вроде этого, название может слегка отличаться или быть на другом языке общения). Это значит, что в командной строке вы получаете те же самые инструменты, которые использует интегрированная среда разработки.
Набор инструментов «Microsoft C++ Build Tools» вы тоже можете использовать бесплатно (как и версию «Community» среды «Microsoft Visual Studio»), но там есть ограничения. Насколько я понимаю, для обучения и разработки программ с открытым исходным кодом этот набор инструментов точно можно использовать бесплатно (тут подробнее). Вот откуда можно загрузить к себе на компьютер этот набор инструментов для использования без IDE:
https://visualstudio.microsoft.com/visual-cpp-build-tools/
https://visualstudio.microsoft.com/downloads/?q=build+tools
У меня, как я упомянул в начале поста, установлена среда «Visual Studio Community 2022» с рабочей нагрузкой, предназначенной для работы с кодом на языке C++. Поэтому в моем случае нет необходимости устанавливать набор инструментов «Microsoft C++ Build Tools» отдельно. Я уже и так имею возможность работать с компилятором «MSVC» как из IDE, так и из командной строки.
Порядок запуска компилятора «MSVC» из командной строки
Компания «Microsoft» не рекомендует запускать инструменты из набора «Microsoft C++ Build Tools» из обычной программы-оболочки с командной строкой, как мы привыкли, так как для этого набора инструментов задействуется много разных переменных среды, которые должны быть правильно настроены. По крайней мере, начинающим этого точно делать не сто́ит.
Для запуска набора инструментов «Microsoft C++ Build Tools» предлагается использовать предварительно настроенные нужным образом версии программ-оболочек, которые можно запустить из меню кнопки «Пуск» операционной системы «Windows 10». В этом меню нужные пункты будут присутствовать, если вы установили набор инструментов «Microsoft C++ Build Tools» либо отдельно, либо в составе интегрированной среды разработки «Microsoft Visual Studio».
У меня в меню кнопки «Пуск» операционной системы присутствуют два подходящих пункта-ярлыка. Их можно быстро найти, набрав в поиске операционной системы (кнопка с увеличительным стеклом рядом с кнопкой «Пуск» на панели задач) слово «developer»:
– Developer Command Prompt for VS 2022
– Developer PowerShell for VS 2022
Первый из них использует программу-оболочку «cmd.exe», а второй — программу-оболочку «Windows PowerShell». Можно запустить любой из этих ярлыков и далее уже работать в открывшейся программе-оболочке, там всё будет настроено так, как следует.
Оба эти ярлыка в качестве хоста используют программу-«эмулятор терминала» «Windows Console», так как я работаю в операционной системе «Windows 10». Но мне уже полюбилась программа-«эмулятор терминала» «Windows Terminal» (предполагается, что «Windows Terminal» заменит «Windows Console» в операционной системе «Windows 11», но у меня нет доступа к «Windows 11», поэтому я не знаю, как оно там), поэтому я предпочитаю запустить ее и открыть программу-оболочку «Developer PowerShell for VS 2022» уже из нее. (У меня, кстати, есть ряд постов про программу-«эмулятор терминала» «Windows Terminal».)
К слову, программу «Windows Terminal» можно загрузить к себе на компьютер бесплатно и она «увидит» все имеющиеся на компьютере программы-оболочки, после чего любую из них можно будет запустить из программы «Windows Terminal».
На практике
Создаю новую папку «test» в местоположении «C:\Users\Илья\source\repos» с помощью программы «Проводник Windows». В принципе, отдельную папку можно не создавать, но я привык для каждой новой задачи (проекта) создавать новую папку, это удобно и это популярный метод работы. Также отмечу, что папку можно создать в любом месте, но я работаю с кодом программ в указанном выше местоположении, мне так удобно.
Перехожу в программе «Проводник Windows» в созданную папку «test» в местоположении «C:\Users\Илья\source\repos». С помощью редактора кода (я использую «Notepad++» или «VS Code», они оба хороши для небольших программ) создаю текстовый файл «first.cpp» в кодировке UTF-8 с сигнатурой (она же — метка BOM). (К сожалению, компилятор «MSVC» принимает файлы в кодировке UTF-8 только с меткой BOM, тут про это подробнее.) Сохраняю в этом файле следующий код (из учебника Лафоре, с добавленными мною измененениями):
#include <io.h> // для функции _setmode #include <fcntl.h> // для константы _O_U16TEXT #include <iostream> using namespace std; int main() { // переключение стандартного потока вывода в формат Юникода _setmode(_fileno(stdout), _O_U16TEXT); wcout << L"У каждой эпохи свой язык\n"; return 0; }
Из контекстного меню (открывается щелчком правой кнопки мыши) запускаю программу-«эмулятор терминала» «Windows Terminal» и создаю в ней новую вкладку с нужной программой-оболочкой:
Как видно на иллюстрации выше, список доступных программ-оболочек можно открыть, нажав на кнопку со значком уголка, направленного вниз, или нажав соответствующее сочетание клавиш на клавиатуре. (При запуске программы «Windows Terminal» автоматически запускается вкладка с программой-оболочкой по умолчанию, у меня это программа-оболочка «PowerShell». Но в данном случае она не нужна и эту первую вкладку можно закрыть.) Вот что получилось:
Далее работаем из командной строки этой программы-оболочки. Сначала предлагается проверить работоспособность компилятора «MSVC». Исполняемый файл этого компилятора называется «cl.exe», поэтому для его запуска нужно использовать команду «cl»:
PS C:\Users\Илья\source\repos\test> cl Оптимизирующий компилятор Microsoft (R) C/C++ версии 19.35.32216.1 для x64 (C) Корпорация Майкрософт (Microsoft Corporation). Все права защищены. использование: cl [ параметр... ] имя_файла... [ /link параметр_компоновки... ]
Приведенный в блоке кода выше выведенный компилятором текст не содержит сообщений об ошибках, а содержит только информацию о владельце программы и короткую инструкцию по использованию компилятора. Значит, все настройки правильные, можно начинать работу.
Создадим из нашей маленькой программы «first.cpp» исполняемый файл:
PS C:\Users\Илья\source\repos\test> cl /EHsc "first.cpp" Оптимизирующий компилятор Microsoft (R) C/C++ версии 19.35.32216.1 для x64 (C) Корпорация Майкрософт (Microsoft Corporation). Все права защищены. first.cpp Microsoft (R) Incremental Linker Version 14.35.32216.1 Copyright (C) Microsoft Corporation. All rights reserved. /out:first.exe first.obj
В нашей папке «test» появилось два новых файла: «first.obj» и «first.exe». Как известно, процесс сборки программы из исходного кода в исполняемый файл обычно проходит в два этапа: 1) компиляция (выполняется компилятором); 2) «линковка», она же «компоновка» (выполняется «линкером», он же — «компоновщик»). На первом этапе из исходного кода (у нас — единственный текстовый файл «first.cpp») создается объектный файл (в нашем случае — «first.obj»). На втором этапе из объектного файла создается исполняемый файл.
Как видно из результата работы компилятора выше, он сначала делает свою работу (создает объектный файл «first.obj»), а затем автоматически запускает линковщик, который создает из объектного файла исполняемый файл. В принципе, компилятор можно заставить не запускать линковщик автоматически с помощью ключа /c. Тогда нужно будет запускать линковщик отдельно, вторым этапом, с помощью команды «link» (исполняемый файл линковщика называется «link.exe»). Такой подход бывает нужен в сложных случаях.
Ключ /EHsc определяет модель обработки ошибок, которая должна быть использована при компиляции. Это рекомендуемый ключ для начинающих.
Вообще у компилятора и компоновщика огромное количество разнообразных ключей, с помощью которых можно выполнить бесчисленное количество разных настроек. Вот тут можно посмотреть на все ключи компилятора «MSVC», перечисленные по алфавиту, чтобы иметь представление о масштабах этого кошмара. Рассмотрение этих ключей, или хотя бы самых полезных из них выходит за рамки этого поста.
Размеры полученных файлов:
PS C:\Users\Илья\source\repos\test> dir
Каталог: C:\Users\Илья\source\repos\test
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 04.04.2023 15:16 423 first.cpp
-a---- 04.04.2023 15:52 231424 first.exe
-a---- 04.04.2023 15:52 122560 first.obj
Как видно из блока кода, приведенного выше, исполняемый файл «first.exe» получился просто огромного размера, если соотнести размер в 226 Кб с тем, что эта программа делает (всего лишь выводит в окно консоли короткую строку). К примеру, если этот же исходный код в файле «first.cpp» скомпилировать в исполняемый файл в среде «Microsoft Visual Studio», то у меня получился исполняемый файл размером 12 Кб, что почти в 19 раз меньше.
Такая большая разница в размерах исполняемого файла получается из-за того, что среда «Microsoft Visual Studio» использует ключи компилятора, предназначенные для оптимизации размера исполняемого файла. Тема оптимизации — это тема не для начинающих. Кому интересно, можно начать изучение этого вопроса отсюда. На период изучения языка C++ по учебнику на размер исполняемого файла можно не обращать внимания. Но при создании реальных полезных программ вопрос оптимизации придется изучить досконально.
Запуск исполняемого файла на выполнение:
PS C:\Users\Илья\source\repos\test> .\first У каждой эпохи свой язык
Как видим из блока кода выше, всё в порядке, программа выполнила свою работу, вывела в окно консоли нужную строку на русском языке.
Отмечу, что приведенный выше исходный код в файле «first.cpp» не является кроссплатформенным, но такая задача не ставилась и этот вопрос выходит за рамки данного поста.
Полезная статья, один из главных источников информации для данного поста: «Walkthrough: Compiling a Native C++ Program on the Command Line» (по-русски «Быстрое ознакомление: компиляция программы на C++ в командной строке»).