Программирование в консоли windows

Была ли эта статья полезной?

In Windows NT (XP, Vista, 7, 8, 10,…) one is able to write batch files that are interpreted by the Command Prompt (cmd.exe). They can be used to automate file-system tasks such as backups or basic installations and can be used with other command-line utilities as well. The batch files can be considered to be a simple scripting language with logic and jumps. The advantages of using batch files are the ease of writing them, the ability to edit the files without compiling anything, their cross-compatibility across Windows NT Operating Systems and their inherent ability to manipulate file systems due to their basis on MS-DOS. Batch file scripts are not case-sensitive, although strings and data are. The file is controlled by a list of commands separated into lines which are run like normal commands would be at the Command Prompt, although some functionality is different. Batch files can be run from Windows Explorer but the console used to display them closes automatically at the end of the batch file, so a command at the end that prevents instantaneous exit is needed for any remaining output to be read before the console window closes. Although the batch files are able to manipulate their environment, such as color settings and environment variables, the changes are all temporary, as in a standard Command Prompt session. Color settings, however, are retained on later editions of Windows NT. In order to try to learn about batch files, it is useful to understand Command Prompt commands. See: Guide to Windows commands.

The script is kept inside a batch file, with the extension .bat or .cmd. Although .bat is more recognisable, as it was used in the MS-DOS environment that preceded the Command Prompt, the Command Prompt’s interpretations of batch files is very different to the manner of interpreting DOS batch files, and .cmd files are only interpreted by the Command Prompt, so using the .cmd extension prevents mis-use in older environments.

Execution starts at the top of the file and ends at the end. When the end of the file is reached, the file exits to the Command Prompt if it was invoked from there, or the console window closes if it was invoked from Windows Explorer or the START command.

Typically, batch files start with the ‘echo off’ command, which stops the input and prompt from being displayed during execution, so only the command output is displayed. The ‘@’ symbol prevents a command from having input and its prompt displayed. It is used on the ‘echo off’ command to prevent that first command from displaying the input and prompt:

@ECHO OFF

In order to print lines, the ECHO command is used again, but this time with a text parameter other than ‘off’:

ECHO.Hello World!

The period (‘.’) is used to prevent confusion with the attempt to output ON or OFF rather than turn input and prompt displaying on and off. The last line in a code should then be:

ECHO ON

‘Echo on’ will turn the input/prompt display back on, just in case the program exits to the Command Prompt where without the command ‘echo on’, there will be no visible prompt left for use.

HINT: Starting with Windows XP, the ECHO ON command is optional. The command interpreter automatically enables it after the BAT file terminates.

Using the code above, we can make a hello world program like so:

@ECHO OFF
ECHO Hello World!
ECHO ON

In batch files there are two ways of writing comments. Firstly there is the form:

REM Comment here.

This form is included as it was in the MS-DOS batch file script. The other form is this:

::Comment here.

This form is generally favoured, for being faster to execute and write, and also for being easy to differentiate from normal commands. For this type of comment only two double-colons (‘::’) are needed and the comment ends at the end of the line. Batch files have no multi-line comment types.

You can also add a comment to the end of the command:

command &::Comment here.

In batch scripting, all variables are strings stored in system memory.
Variables are assigned using the SET command. Variables assigned in this manner persist in the System environment alongside predefined Global System variables until the environment in which they are defined is terminated, either through the use of the ENDLOCAL command or the closing of the command prompt session. Care should be taken to avoid ‘overwriting’ Global environment variables such as ‘PATH’ ‘TIME’ ‘DATE’, as other programs can be dependent on them having their ‘proper’ value.

• The use of the command ‘GOTO :EOF’ in an environment where the command ‘SETLOCAL’ has created a child environment implies and effects an ‘ENDLOCAL’ command.

SET name=John Smith

This command creates an environment variable called name, and sets its value to the string «John Smith». White space on either side of the first ‘=’ sign is included in the assignment of both the variables reference name (‘name’ in this instance) and the variables value [Variable names can contain whitespace!]. Trailing whitespace in a variables value is also assigned, which can cause unexpected failure in some scripts if not detected. For this reason, it is recommended to quote the assignment of variables:

SET "name=John Smith"

Variables are generally used within other commands by expanding the reference string with ‘%’ characters marking the beginning and end of the variable reference string:

ECHO %name%

In batch scripting, variables that are expanded using ‘%’ expansion are read [parsed] by the interpreter prior to the line or block being executed. As such, this means the command will execute with the value the variable held prior to the commencement of that section of code. This is especially significant where code blocks are used and the variables value is reassigned within that code block.
A code block in batch scripting occurs when multiple commands are chained together on the same line using ‘&’ to concatenate the commands; as well as within any parenthesised code such as ‘IF’ statements and ‘FOR’ loops.

An example that demonstrates the problem this poses:

@Echo off
Set "count=0"
For /L %%n in (1 1 3)Do (
 Set /A count+=1
 Echo %count%
)
Echo %count%

Output:

0
0
0
3

There are 2 methods for resolving this. The first and most commonly used is to Enable Delayed Expansion, which allows variables to be expanded using ‘!’ (delayed) expansion:

@Echo off
Set "count=0"
SETLOCAL EnableExtensions EnableDelayedExpansion
For /L %%n in (1 1 3)Do (
 Set /A count+=1
 Echo !count!
)
Echo %count%

Output:

1
2
3
3

Using Delayed Expansion results in the variable being expanded during execution instead of when the command is initially parsed by the interpreter.

The 2nd method of expanding a variables current value during code blocks is to use the ‘CALL’ command to effectively reset the parser during execution of the command so the current value is read.

@Echo off
Set "count=0"
For /L %%n in (1 1 5)Do (
 Set /A count+=1
 Call Echo %%count%%
)
Echo %count%

The call method is significantly slower, However is useful for dealing with strings that may include ‘!’ characters that the interpreter would attempt to parse as a variable when delayed expansion is enabled. It is not suitable for strings containing Carets ‘^’ as the call command doubles Carets that occur in the command string that follows the Call.

The use of Delayed expansion allows ‘Associated’ variables to be defined using a common reference name with unique indexes to emulate arrays.
This is possible because while Delayed Expansion enabled, expansion of variables occurs in two steps. First, ‘%’ variables are expanded, then ‘!’ variables are expanded. Example:

@Echo off
 Set "str[1]=one,three,five"
 Set "str[2]=two,four,six"
 Setlocal EnableExtensions EnableDelayedExpansion
rem for each in 1 2
 For %%i in (1 2)Do (
rem reset sub index variable
  Set "{i}=0"
rem for each in variable str[index]
  For %%G in (!str[%%i]!)Do (
rem increment sub index count
   Set /A {i}+=1
rem define element '{i}' from str[index] to str[index][subindex]
   Set "str[%%i][!{i}!]=%%G"
  )
 )
Set Str
Goto :Eof

Output:

str[1]=one,three,five
str[1][1]=one
str[1][2]=three
str[1][3]=five
str[2]=two,four,six
str[2][1]=two
str[2][2]=four
str[2][3]=six

The set command can also be used for input:

SET /P var=Enter a value for var:

This command displays «Enter a value for var:» and when the user enters the data, var is given that value.

Be aware, if the user presses enter without entering anything then the value in var is unchanged, so for the sake of a prompt it is often best to give a default value, or clear the value for the variable first if it has been used before:

SET var=
SET /P var=Enter a value for var:

Below is an example:

@ECHO OFF
SET /P answer= Enter name of file to delete: 
DEL /P %answer%
ECHO ON

This batch file gets the name of a file to delete and then uses the DEL command with the prompt parameter ‘/P’ to ask the user if they’re sure they want to delete the file.

The IF command can be used to create program logic in batch files. The IF command allows three basic checks, on the ERRORLEVEL, the equality of two strings, and the existence of a file or folder. The first check on the ERRORLEVEL will check to see if it is greater than or equal to a certain number:

IF ERRORLEVEL 5 ECHO.The ERRORLEVEL is at least 5.

For this style the first parameter is always ERRORLEVEL, and the second is the value it checks against. In this case, if the ERRORLEVEL is at least 5 then the command at the end of the line is executed, outputting the message «The ERRORLEVEL is at least 5.». The second form is a check between two strings:

IF "%str1%"=="Hello." ECHO.The strings are equal.

Here the first parameter is two strings either side of the double ‘=’, symbolising a check to see if they are equal. If the variable str1 is exactly equal to «Hello.», a check which is case-sensitive, then «The strings are equal.» is outputted. In the case that you wish to make the check case-insensitive you would rewrite it as following:

IF /I "%str1%"=="Hello." ECHO.The strings are equal.

Now, for example, str1 could contain «HELLO.» but the check would still result in the command being executed at the end as the check is now case-insensitive. The final basic IF type is the existence check, to see if a file or folder exists.

IF EXIST myfile.txt TYPE myfile.txt

Here if the file «myfile.txt» exists in the current folder then the command TYPE myfile.txt is executed which displays the contents of «myfile.txt» in the console window.

All of the preceding examples have an optional NOT parameter that can be written after the IF which will execute the command at the end of the line if the condition is not true. For example:

IF NOT EXIST myfile.txt ECHO.File missing.

Which will output «File missing.» if the file «myfile.txt» is not existent in the current folder. There are a few other IF types with command extensions, which can be seen with the IF /? command at the command prompt.

The ELSE operator can be used with a combination of brackets to provide multi-line logical statements that provide an alternative set of commands if the condition is not true.

IF condition (
   commands to be executed if the condition is true 
) ELSE (
   commands to be executed if the condition is false
)

Unlike some languages, in batch files the scripting requires that the lines IF condition (, ) ELSE ( and ) are written very specifically like that. It is possible, however, to re-write it to use single-line outcomes all on one line:

IF condition (command if true) ELSE command if false

Below is an example of the ELSE operator in use:

@ECHO OFF
::Prompt for input.
SET /P answer=Enter filename to delete: 
IF EXIST %answer% (
 DEL /P %answer%
) ELSE (
 ECHO.ERROR: %answer% can not be found in this folder!
)
ECHO ON

This batch file will delete a file, unless it doesn’t exist in which case it will tell you with the message «ERROR: %answer% can not be found in this folder!».

Unlike in most computer languages, multiple multi-line IF…ELSE style statements can’t be nested in batch files.

You can control program flow using the GOTO statement. Batch files don’t have all elements for structured programming scripting, however some elements of structured programming such as functions can be simulated. The simplest way of controlling program flow, however, is the GOTO statement which jumps to a specified label.

GOTO labelnam

This code will direct program flow to the label labelnam, which is found at the first occurrence of this line:

:labelnam

It is important to remember that labels only store 8 characters, so if a label is longer than 8 characters only the first 8 will be seen. This means the labels labelname1 and labelname2 can’t be distinguished from each other as their only difference occurs past the first 8 characters. Although not strictly incorrect, it is better to avoid using label names longer than 8 characters to avoid these distinguishing problems easily.

Here is the example from earlier redesigned to loop until asked to stop:

@ECHO OFF

:prompt
::Clear the value of answer ready for use.
SET answer=
SET /P answer=Enter filename to delete (q to quit): 

IF EXIST %answer% (
 DEL /P %answer%
 GOTO prompt
)
IF /I "%answer%"=="q" GOTO :EOF

::By this point an error must have occurred as all
::the correct entries have already been dealt with.
ECHO.ERROR: Incorrect entry!
GOTO prompt

ECHO ON

Take note of the command GOTO :EOF. This command will take the script to the end of the file and end the current batch script.

Runs a specified command for each file in a set of files.

   FOR %variable IN (set) DO command [command-parameters]

 %variable  Specifies a single letter replaceable parameter.
 (set)      Specifies a set of one or more files.  Wildcards may be used.
 command    Specifies the command to carry out for each file.
 command-parameters
            Specifies parameters or switches for the specified command.

To use the FOR command in a batch program, specify %%variable instead
of %variable. Variable names are case sensitive, so %i is different
from %I.

Batch File Example:

 for %%F IN (*.txt) DO @echo %%F

This command will list all the files ending in .txt in the current directory.

If Command Extensions are enabled, the following additional
forms of the FOR command are supported:

   FOR /D %variable IN (set) DO command [command-parameters]

If set contains wildcards, then specifies to match against directory
names instead of file names.

   FOR /R [[drive:]path] %variable IN (set) DO command [command-parameters]

Walks the directory tree rooted at [drive:]path, executing the FOR
statement in each directory of the tree. If no directory
specification is specified after /R then the current directory is
assumed. If set is just a single period (.) character then it
will just enumerate the directory tree.

   FOR /L %variable IN (start,step,end) DO command [command-parameters]

The set is a sequence of numbers from start to end, by step amount.
So (1,1,5) would generate the sequence 1 2 3 4 5 and (5,-1,1) would
generate the sequence (5 4 3 2 1)

   FOR /F ["options"] %variable IN (file-set) DO command [command-parameters]
   FOR /F ["options"] %variable IN ("string") DO command [command-parameters]
   FOR /F ["options"] %variable IN ('command') DO command [command-parameters]

or, if usebackq (or useback) option present:

   FOR /F ["options"] %variable IN ("file-set") DO command [command-parameters]
   FOR /F ["options"] %variable IN ('string') DO command [command-parameters]
   FOR /F ["options"] %variable IN (`command`) DO command [command-parameters]

(The purpose of usebackq is to use a fullname of file-set including the space.)

filenameset is one or more file names. Each file is opened, read
and processed before going on to the next file in filenameset.
Processing consists of reading in the file, breaking it up into
individual lines of text and then parsing each line into zero or
more tokens. The body of the for loop is then called with the
variable value(s) set to the found token string(s). By default, /F
passes the first blank separated token from each line of each file.
Blank lines are skipped. You can override the default parsing
behavior by specifying the optional «options» parameter. This
is a quoted string which contains one or more keywords to specify
different parsing options. The keywords are:

   eol=c           - specifies an end of line comment character
                     (just one)
   skip=n          - specifies the number of lines to skip at the
                     beginning of the file.
   delims=xxx      - specifies a delimiter set.  This replaces the
                     default delimiter set of space and tab.
   tokens=x,y,m-n  - specifies which tokens from each line are to
                     be passed to the for body for each iteration.
                     This will cause additional variable names to
                     be allocated.  The m-n form is a range,
                     specifying the mth through the nth tokens.  If
                     the last character in the tokens= string is an
                     asterisk, then an additional variable is
                     allocated and receives the remaining text on
                     the line after the last token parsed.
   usebackq        - specifies that the new semantics are in force,
                     where a back quoted string is executed as a
                     command and a single quoted string is a
                     literal string command and allows the use of
                     double quotes to quote file names in
                     filenameset.

Some examples might help:

   FOR /F "eol=; tokens=2,3* delims=, " %i in (myfile.txt) do @echo %i %j %k

would parse each line in myfile.txt, ignoring lines that begin with
a semicolon, passing the 2nd and 3rd token from each line to the for
body, with tokens delimited by commas and/or spaces. Notice the for
body statements reference %i to get the 2nd token, %j to get the
3rd token, and %k to get all remaining tokens after the 3rd. For
file names that contain spaces, you need to quote the filenames with
double quotes. In order to use double quotes in this manner, you also
need to use the usebackq option, otherwise the double quotes will be
interpreted as defining a literal string to parse.

%i is explicitly declared in the for statement and the %j and %k
are implicitly declared via the tokens= option. You can specify up
to 26 tokens via the tokens= line, provided it does not cause an
attempt to declare a variable higher than the letter ‘z’ or ‘Z’.
Remember, FOR variables are single-letter, case sensitive, global,
and you can’t have more than 52 total active at any one time.

You can also use the FOR /F parsing logic on an immediate string, by
making the filenameset between the parenthesis a quoted string,
using single quote characters. It will be treated as a single line
of input from a file and parsed.

Finally, you can use the FOR /F command to parse the output of a
command. You do this by making the filenameset between the
parenthesis a back quoted string. It will be treated as a command
line, which is passed to a child CMD.EXE and the output is captured
into memory and parsed as if it was a file. So the following
example:

   FOR /F "usebackq delims==" %i IN (`set`) DO @echo %i

would enumerate the environment variable names in the current
environment.

In addition, substitution of FOR variable references has been enhanced.
You can now use the following optional syntax:

   %~I         - expands %I removing any surrounding quotes (")
   %~fI        - expands %I to a fully qualified path name
   %~dI        - expands %I to a drive letter only
   %~pI        - expands %I to a path only
   %~nI        - expands %I to a file name only
   %~xI        - expands %I to a file extension only
   %~sI        - expanded path contains short names only
   %~aI        - expands %I to file attributes of file
   %~tI        - expands %I to date/time of file
   %~zI        - expands %I to size of file
   %~$PATH:I   - searches the directories listed in the PATH
                 environment variable and expands %I to the
                 fully qualified name of the first one found.
                 If the environment variable name is not
                 defined or the file is not found by the
                 search, then this modifier expands to the
                 empty string

The modifiers can be combined to get compound results:

   %~dpI       - expands %I to a drive letter and path only
   %~nxI       - expands %I to a file name and extension only
   %~fsI       - expands %I to a full path name with short names only
   %~dp$PATH:I - searches the directories listed in the PATH
                 environment variable for %I and expands to the
                 drive letter and path of the first one found.
   %~ftzaI     - expands %I to a DIR like output line

In the above examples %I and PATH can be replaced by other valid
values. The %~ syntax is terminated by a valid FOR variable name.
Picking upper case variable names like %I makes it more readable and
avoids confusion with the modifiers, which are not case sensitive.

this is mainly used to redirect the output of one program to another program

a | b

means execute «a» and what all output «a» gives to the
console — give that as «b» s input

dir | find ".htm"

will give a list of file which contain «.htm» in their names

The output of a command as well as possible errors could be redirected also to files (Note the 2 in front of the >> ):

ACommand >>TheOutputOfTheCommandLogFile.log 2>>TheErrorOutputOfTheCommandFile.log

Functions may be simulated by using labels to control flow of execution, and using an environment variable to return the resulting return value. Labels can be defined at any place in the script and do not need to be referenced. The code following the label will be executed when encountered. Code blocks identified by labels are usually most conveniently placed after the main script has exited (at the end of the file) so that they will not run accidentally, but will be reached only when targeted by a GOTO or CALL statement.

The subroutine construct works because of the following:

• Code identified by a label can be jumped to by using the GOTO built in command
• Using the CALL built in command with a label creates a new invocation of the command processor for the same script, with an implicit GOTO the label
• Using the expression GOTO :EOF closes the current command processor invocation (Same as EXIT /B except the latter allows to specify an ERRORLEVEL)

The structure of a subroutine call looks like this:

CALL :subroutine1 param1 param2 ...
ECHO %result% was returned from subroutine1

CALL :subroutine2 param1 param2 ...
ECHO %result% was returned from subroutine2

GOTO :EOF
REM The above line ends the main invocation of the command processor and so exits the script

:subroutine1 
  SETLOCAL
  commands using parameters %1, %2, .... and setting %retval%
  ENDLOCAL & SET result=%retval% 
  GOTO:EOF
  REM The above line ends the child invocation of the command processor and so returns to just after CALL subroutine1 in the main script

:subroutine2 
  SETLOCAL
  commands using parameters %1, %2, .... and setting %retval%
  ENDLOCAL & SET result=%retval% 
  GOTO:EOF
  REM The above line ends the child invocation of the command processor and so returns to just after CALL subroutine2 in the main script

Bat file with next content outputs «42» as result of execution

:: describes and calls function for multiplication with 2 arguments
@ECHO OFF
CALL :multiply 21 2 
ECHO %result% 

:multiply
SETLOCAL
set retval=0
set left=%1
set right=%2
:: use '/A' for arithmetic
set /A "retval=left*right" 
ENDLOCAL & SET result=%retval% 
GOTO :EOF

Note:

• Using CALL with a label or the expression CALL :EOF or EXIT /B requires command extensions to be enabled.
• A label is a line consisting of a valid name (not containing any separators such as space or semicolon) prefixed by a colon.

let’s say we want to call a program «MyProgram» from the command prompt. we type the following into our prompt (the .exe file extension is unnecessary):

C:\>myprogram.exe

And this will run the myprogram executable. Now, let’s say we want to pass a few arguments to this program:

C:\>myprogram arg1 arg2 arg3

Now, if we go into the standard main function, we will have our argc and argv values:

int main(int argc, char *argv[])

Where:

argc = 4
argv[0] = "myprogram" (the name of the program - deduct 1 from argc to get the number of arguments)
argv[1] = "arg1"
argv[2] = "arg2"
argv[3] = "arg3"

This shouldn’t come as a big surprise to people who have any familiarity with standard C programming. However, if we translate this to our WinMain function, we get a different value:

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR CmdLine, int iCmdShow)

we will only have one value to accept the command line:

CmdLine = "myprogram arg1 arg2 arg3".

We can also use the function GetCommandLine to retrieve this string from any point in the application. If we want to parse this into a standard argv/argc pair, we can use the function CommandLineToArgvW to perform the conversion. It is important to note that CommandLineToArgvW only works on unicode strings.

When we return a value from our C program, that value gets passed to the CMD shell, and stored in a variable called «ERRORLEVEL». ERRORLEVEL is the only global variable that is not a string, and it can contain a number from 0 to 255. By convention, a value of zero means «success», while a value other then zero signifies an error.

Let’s say we wanted to write a C program that returns the number of arguments passed to it. This might sound like a simple task in C, but it is difficult to accomplish in batch script:

int main(int argc, char *argv[])
{
   return (argc - 1);
}

And we will name this program «CountArgs.exe». Now, we can put this into a batch script, to pass it a number of arguments, and to print out the number passed:

countargs.exe %*
ECHO %ERRORLEVEL%

We can, in turn, call this script «count.bat», and run that from a command prompt:

C:\>count.bat arg1 arg2 arg3

and running this will return the answer: 3.

NOTE: Actually, this can be accomplished with a batch file without resorting to a C program, by simply using CMD delayed variable expansion via the «/V:ON» parameter:

/V:ON   Enable delayed environment variable expansion using ! as the 
delimiter. For example, /V:ON would allow !var! to expand the variable 
var at execution time.  The var syntax expands variables at input time, 
which is quite a different thing when inside of a FOR loop.

Then use a simple batch file like the following to count parameters:

set COUNT=0
for %%x in (%*) do ( set /A COUNT=!COUNT!+1 )
echo %COUNT%

Or an easier way, without having to enable & use ‘delayed environment expansion’, would be to do the following:

set COUNT=0
for %%x in (%*) do set /A COUNT+=1
echo COUNT = %COUNT%

This returns the same answer as the C program example.

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.

Картинка с сайта: www.geeksforgeeks.org

• 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

Картинка с сайта: www.geeksforgeeks.org

• Click on Installation menu to install > Select Apply changes option for packages > Click on Apply button

Картинка с сайта: www.geeksforgeeks.org

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

Картинка с сайта: www.geeksforgeeks.org

• 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

Картинка с сайта: www.geeksforgeeks.org

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

Картинка с сайта: www.geeksforgeeks.org

• Right-click on the Command Prompt from the home screen > Select Run as Administrator option > Run «gcc — version» at the prompt option to execute

Картинка с сайта: www.geeksforgeeks.org

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.

Картинка с сайта: www.geeksforgeeks.org

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.

Картинка с сайта: www.geeksforgeeks.org

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;
}

It is Armstrong No.

Картинка с сайта: www.geeksforgeeks.org

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

Интерфейс командной строки для начинающих разработчиков

Если вы когда-либо читали инструкции от разработчиков, то наверняка видели фразы вроде: «Откройте консоль», «Выполните эту команду в терминале» или «Для этого потребуется командная строка». Эти инструменты часто называют невероятно мощными и полезными, но что это означает на практике? Почему терминал считается незаменимым инструментом разработчика и какие возможности он предоставляет, выходя за рамки привычных графических интерфейсов?

Меня зовут Евгений Бартенев, и я автор и техлид курса «Python-разработчик» в Яндекс Практикуме. В этой статье я расскажу, что стоит за терминами «терминал», «оболочка» и «командная строка», а также разберу их некоторые отличия и особенности. Вы узнаете, как они связаны друг с другом и почему работа через консоль зачастую оказывается быстрее и эффективнее. Мы также рассмотрим некоторые практические примеры, которые трудно реализовать, полагаясь только на графический интерфейс.

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

Разбор в ролике для тех, кто предпочитает видеоформат.

Терминология

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

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

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

Терминал — это интерфейс для ввода-вывода текста, через который можно взаимодействовать с операционной системой.

В каждой операционной системе по умолчанию есть один или несколько терминалов, например:

• в Windows — Windows Terminal, Windows Console Host;

• в Linux — GNOME Terminal, Konsole;

• в macOS — Terminal.app.

Хотя в обиходе слова «терминал» и «консоль» часто используют как синонимы, технически эти понятия различаются:

• терминал — это интерфейс для работы с текстом;

• консоль может означать как физическое устройство (например, монитор и клавиатуру в старых компьютерах), так и программу для доступа к терминалу.

При работе с терминалом вы на самом деле взаимодействуете с оболочкой (shell).

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

Оболочки по умолчанию:

• Windows: Command Prompt, PowerShell.

• Linux: большинство дистрибутивов Linux используют bash (Bourne Again SHell) как оболочку по умолчанию. Некоторые новые дистрибутивы начали переходить на zsh (Z shell, произносится как «зет-шелл»).

• macOS: до macOS Catalina оболочкой по умолчанию была bash. Начиная с macOS Catalina и позже, Apple перешла на использование zsh в качестве оболочки по умолчанию.

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

Обычно оболочки поддерживают сотни, а некоторые даже тысячи команд. Чтобы как-то навести порядок в этом многообразии возможностей, стали появляться различные стандарты. Среди таких стандартов особенно выделяется POSIX (Portable Operating System Interface). Он определяет ключевой набор текстовых команд и их ожидаемые результаты. Если оболочка называется POSIX-совместимой, это означает, что она поддерживает этот установленный набор команд.

Точное количество существующих оболочек определить сложно, поскольку их разработано множество, и новые продолжают появляться. Наиболее известные и популярные POSIX-оболочки — это bash (Bourne-Again SHell), Dash (Debian Almquist shell), ksh (Korn shell), ash (Almquist shell), zsh. А вот оболочки Fish (Friendly interactive shell), PowerShell, Command Prompt, Eshell не поддерживают POSIX, поэтому даже для одноимённых команд в каждой из них можно получить различный результат.

В этой статье я сфокусировался на возможностях именно POSIX-совместимых оболочек на примере zsh в операционной системе macOS.

Переключение между оболочками

Запустить интерфейс командной строки в операционной macOS можно по-разному. Чтобы открыть терминал с помощью Spotlight, достаточно нажать сочетание клавиш Command (⌘) + Пробел и в появившейся строке начать вводить слово Terminal. Как только терминал появится в списке предложений, выберите его нажатием клавиши Enter.

Картинка с сайта: habr.com

По умолчанию в macOS используется оболочка zsh, но вы можете переключиться на другую, например bash. Для этого выполните в терминале команду bash — заголовок окна изменится, а в самом окне изменится приглашение для ввода команд.

Картинка с сайта: habr.com

В macOS по умолчанию предустановлена устаревшая версия bash (3.2), что связано с политикой Apple, направленной на использование лицензий, не обременённых условиями GPLv3. Для использования актуальной версии bash необходимо выполнить дополнительные действия, например установить обновление через менеджер пакетов Homebrew.

Чтобы вернуться в оболочку zsh, введите и выполните команду exit.

Картинка с сайта: habr.com

На macOS предустановлены и другие оболочки. Чтобы увидеть все оболочки, доступные в вашей системе, выполните команду:

cat /etc/shells

На стандартной macOS вы увидите что-то вроде:

Картинка с сайта: habr.com

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

Базовые возможности оболочки

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

Клавиши стрелка вправо и стрелка влево перемещают курсор на один символ вправо и влево, а при одновременном удержании клавиши Option — вправо и влево можно перемещаться уже по словам.

Оболочка zsh поддерживает удобное автодополнение. Просто начните вводить команду или путь к файлу, а затем нажмите Tab. Оболочка предложит варианты завершения. Если доступно несколько вариантов, zsh отобразит их список.

Картинка с сайта: habr.com

Если вы не уверены в том, как использовать ту или иную команду, можно обратиться за справкой. Для этого введите команду man (англ. manual, «руководство»), которая открывает полное описание команды, например: man ls.

Картинка с сайта: habr.com

Выйти из режима просмотра можно, нажав на клавишу q.

Если терминал заполнен текстом и вы хотите начать с чистого экрана, достаточно ввести команду clear или использовать сочетание клавиш Command + K.

Очистка экрана в терминале, например с помощью команды clear, не удаляет историю введённых команд — она просто очищает текущее отображение в окне терминала, оставляя всё, что вы вводили ранее, доступным для поиска. Это значит, что вы по-прежнему можете использовать клавиши стрелка вверх и стрелка вниз, чтобы пролистать недавно введённые команды.

Если нужная команда была введена давно, искать её вручную стрелками может быть неудобно. В таком случае поможет команда history. Она выводит список всех команд, которые вы вводили, вместе с их порядковыми номерами. Например, после выполнения команды history вы увидите что-то вроде этого:

Картинка с сайта: habr.com

Теперь, зная номер нужной команды, вы можете выполнить её снова, используя сокращённый синтаксис !<номер>.

Например, команда !73 повторит команду pwd (англ. print working directory, «напечатай рабочую папку»).

Картинка с сайта: habr.com

Псевдонимы

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

Для создания псевдонима, который будет доступен только в текущей сессии терминала, используется команда alias:

alias имя='команда'

Например:

alias ll='ls -la'

Теперь при вводе и выполнении команды ll будет выполняться команда ls -la.

Чтобы увидеть все активные псевдонимы, выполните команду alias.

Картинка с сайта: habr.com

Для удаления псевдонима используйте команду unalias:

unalias ll

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

echo "alias ll='ls -la'" >> ~/.zshrc

После внесения изменений перезапустите оболочку или выполните source ~/.zshrc

Перенаправление потоков

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

Основных потоков три:

• Стандартный ввод (stdin) — это поток, откуда программа получает данные. Обычно это клавиатура.

• Стандартный вывод (stdout) — это поток, куда программа отправляет свои результаты. Обычно это вывод в окне терминала.

• Стандартный поток ошибок (stderr) — это поток для сообщений об ошибках. Он отделён от стандартного вывода, чтобы ошибки не смешивались с обычным результатом программы.

Допустим, вы выполняете команду ls. Выполнение команды ls создаёт список файлов и выводит его в стандартный вывод (stdout), то есть на экран. Однако это можно изменить.

Допустим, вам требуется сохранить весь вывод в файл. И самый простой способ сделать это — перенаправить поток. Для этого используется команда >.

ls > output.txt

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

Подобным же образом стандартный ввод (stdin) программы можно перенаправить с клавиатуры на файл. Для этого используется символ <.

python3 myscript.py < input.txt

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

Конвейеры

Когда вы вводите команду в оболочке, она запускается и выполняется. Результат выполнения команды обычно отображается на экране. Однако в POSIX-совместимых оболочках результат выполнения одной команды вместо вывода на экран можно передать другой команде. Это позволяет создавать последовательности команд для обработки данных. Этот механизм носит название конвейеров (иногда их ещё называют пайплайны) и при написании команд обозначается символом |.

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

Например:

cat input.txt | wc -l

Отдельное выполнение команды cat input.txt выводит содержимое файла input.txt, а команда wc -l подсчитывает количество строк в выводе.

Запуск конвейера из этих команд даст только финальный результат — количество строк, минуя промежуточные результаты.

Картинка с сайта: habr.com

Или вот другой пример:

ls -l | sort -k 5 -n

Команда ls -l выводит список файлов с подробной информацией, а запуск команды sort -k 5 -n сортирует вывод по пятому столбцу (размеру файлов). В результате выполнения конвейера мы сразу же получим необходимый результат.

Картинка с сайта: habr.com

А вот более сложный пример. У нас есть текстовый файл log.txt, содержащий список IP-адресов пользователей, подключавшихся к серверу.

192.168.0.1
192.168.0.2
192.168.0.1
192.168.0.3
192.168.0.2
192.168.0.1

Надо найти IP-адрес хакера, который решил загрузить наш сервер подключениями, вывести этот IP-адрес вместе с количеством подключений, попутно сохранить результат в файл top_user.txt. Из инструментов у нас только оболочка zsh.

В качестве решения задачи можно использовать следующий конвейер:

cat log.txt | sort | uniq -c | sort -nr | awk 'NR==1 {print $2, $1}' | tee top_user.txt

Тут каждая команда выполняет свою задачу, разберём их по порядку.

1. cat log.txt — читает содержимое файла log.txt и передаёт его в конвейер.

2. sort — сортирует IP-адреса, чтобы одинаковые IP-адреса оказались рядом.

3. uniq -с — подсчитывает количество повторений каждой уникальной строки (IP-адреса). Флаг -c добавляет число повторений перед каждым IP.

4. sort -nr — сортирует строки по числовым значениям в порядке убывания (флаг -nr: -n — числовая сортировка, -r — обратный порядок).

5. awk 'NR==1 {print $2, $1}' — обрабатывает только первую строку (самый активный IP-адрес) благодаря фильтру NR==1. Команда {print $2, $1} выводит второй столбец (IP-адрес) и первый столбец (количество подключений).

6. tee top_user.txt — записывает результат в файл top_user.txt и одновременно выводит его на экран.

Картинка с сайта: habr.com

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

В теории количество действий (команд) в конвейере оболочки (например, в bash или zsh) практически не ограничено. Однако на практике существуют технические и системные ограничения, которые определяют максимальную длину конвейера. Например, максимальный размер аргументов командной строки можно получить при помощи команды getconf ARG_MAX.

Логические операторы

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

Например, команда справа от && выполняется, только если команда слева завершилась успешно (код завершения 0).

mkdir new_dir && cd new_dir

Если mkdir new_dir выполнится успешно (директория будет создана), тогда выполнится cd new_dir — переход в созданную директорию. Если первая команда завершится с ошибкой (например, папка уже существует), вторая команда не будет выполнена.

Картинка с сайта: habr.com

Команда справа от || выполняется, только если команда слева завершилась с ошибкой (код завершения не 0).

mkdir new_dir || echo "Directory already exists"

Если mkdir new_dir завершится с ошибкой, будет выполнена команда echo. Если директория успешно создалась, то вторая команда не выполняется.

Картинка с сайта: habr.com

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

mkdir new_dir && echo "Directory created" || echo "Failed to create directory"

Если команда mkdir new_dir успешно выполнена — выполняется echo «Directory created». Если же выполнение mkdir new_dir привело к ошибке — выполняется echo "Failed to create directory".

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

(mkdir new_dir && echo "Directory created") || echo "Failed to create directory"

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

Условия

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

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

Давайте рассмотрим, как это выглядит на практике.

Итак, конструкция if проверяет условие и выполняет определённые команды, если это условие истинно (то есть возвращает код завершения 0). Если условие ложно, можно указать команды для выполнения через else или дополнительные проверки через elif.

Например, предположим, что вы работаете с сервером, где нужно ежедневно проверять наличие файла с данными (например, отчёта), и если файла нет, то отправить уведомление администратору, ну или просто вывести сообщение в консоль.

Вот как это можно сделать с помощью конструкции if:

if [ -f input.txt ]; then
    echo "File exists"
elif [ -d input.txt ]; then
    echo "This is a directory"
else
    echo "File does not exist"
fi

Здесь [ -f input.txt ] проверяет, существует ли файл с именем input.txt. Если файла нет, проверяется условие [ -d input.txt ], которое проверяет, является ли объект директорией. Если оба условия ложны, выполняется блок else.

Картинка с сайта: habr.com

Циклы

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

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

for file in *.jpg
do
    mv "$file" "$(date +%Y-%m-%d)_$file"
done

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

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

for file in *.txt
do
    echo "Processing $file"
done

Здесь переменная file принимает поочерёдно имена всех файлов с расширением .txt в текущей директории и для каждого файла выводится сообщение Processing <имя_файла>.

Картинка с сайта: habr.com

Как и в большинстве языков программирования, в циклах, используемых в оболочках терминалов, доступны конструкции break и continue. С их помощью можно более гибко управлять выполнением цикла: break позволяет досрочно завершить выполнение цикла при выполнении определённого условия, а continue пропускает текущую итерацию и сразу переходит к следующей.

Чем ещё интересны POSIX-совместимые оболочки?

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

• Использование регулярных выражений позволит эффективно искать и править текст, обрабатывать логи и анализировать данные.

• Создание собственных функций поможет вам персонализировать оболочку и ускорить выполнение часто используемых задач.

• Модификация окружения оболочки через написание конфигурационных файлов, таких как ~/.bashrc или ~/.zshrc, позволит настроить автодополнение, цветовые схемы и переменные окружения.

• Использование сторонних плагинов, таких как Oh My Zsh, позволит улучшить автодополнение, добавит красивые подсказки и расширенную интеграцию с Git.

• Взаимодействие с сетевыми утилитами или с такими инструментами, как curl, wget, ssh и scp, поможет выполнять сетевые операции прямо из командной строки.

• Управление процессами даст возможность работать с фоновыми и приостановленными процессами и управлять приоритетами процессов.

• Отладка скриптов позволит использовать инструменты вроде set -x и trap для пошагового анализа выполнения команд.

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

Что в итоге?

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

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

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