Sublime Text 3 Configuring the C + + compilation Environment

Sublime Text 3 provides build functionality that builds systems that can run an external command and capture output and display.

To implement the compilation and operation of C or C + + code in sublime text 3, which is essentially a call to external commands , Windows can also be understood as executing a cmd command.

At present, the most popular is gcc and g++, this article will start from MinGW, introduce the basic command format of GCC and g++, then detail the compilation configuration file in sublime and analyze the function of each line. The build configuration file for C, C + + is then given in Win7 64bit under Sublime Text 3 build 3083.

In addition, the article also introduces the content of using make in Sublime, and discusses the problem of Chinese coding.

If you only want to configure the compilation environment quickly and do not care about implementation details ( not recommended ), you can read only the sections that install MINGW, configure environment variables, and write your own compilation configuration files.

About GCC and g++

Installing the compiler is the basis for all the work behind it, and without the compiler, everything behind it is out of the way. Using GCC and g++ under Windows is implemented by installing MinGW.

Installing MinGW

MINGW is the acronym for Minimalist GNU on Windows and can be installed with a lot of GNU tools. GNU (GNU's not Unix) is a well-known project in Linux and includes tools such as GCC\G++\GDB. In other words, after installing MinGW, we can use the GCC and g++ commands.

MinGW's official website is http://www.mingw.org/, but the installation from the official website is very troublesome, online installation often turtle speed easy to fail.

The recommended method is to use Codeblocks, choose a version with MinGW installation, after installation of the MinGW folder copy it.

Here is a copy of the MinGW that is used to understand the pressure plate, which is reproduced after installation using Codeblocks-13.12mingw-setup:

Http://pan.baidu.com/s/1gd5YzVP

After extracting, we can find the Gcc.exe and g++.exe we need in the Mingw/bin directory.

I'll put the MinGW folder in the C packing directory.

Using gcc in cmd

Suppose we have a test.c file in the work directory of the z-disk. First, we will enter this directory in CMD. You can do this by holding down shift right-click in the work directory and selecting "Open Command Window Here", or you can use the CD command to enter.

The general format of GCC is

GCC source file name-o executable file name

But we enter the command

GCC Test.c-o Test

Prompt after execution

' GCC ' is not an internal or external command, nor is it a running program or batch file.

This is because when the command executes, it looks for an executable file named GCC under the current directory, and if it does not find the GCC executable file in the path record of the system environment variable. But there are none of the two places. The directory where our GCC files are located is the Mingw/bin under C drive.

You can use an absolute path to invoke the GCC executable file

Z:\work>c:/MinGW/bin/gcc test.c -o test
 
Z:\work>test.exe
hello world

This compiles the executable file Test.exe successfully, and then it can be run in CMD.

Configuring Environment variables

For convenience, we usually add the path of GCC to the environment variables of the system, so that you can use the GCC command directly instead of the absolute path.

Environment variables, advanced system settings, properties, right-click Computer

In the value of path, you can find some directories that are separated by semicolons in English .   We double-click on path to add our GCC path C:\MinGW\bin. Be aware of the English semicolon before and after.

Make sure you can use GCC commands directly in any directory. You can open the CMD window in any directory and enter GCC to see if the environment variable is set successfully. If the prompt is still not an internal or external command, the environment variable setting fails.

Note: in sublime text 3 build 3083, changes to the environment variables do not take effect immediately in sublime and require a restart of Windows.

CMD compile run C language

Summarize the process:

First we have to enter the directory where the. c file is in CMD as the working directory

Then execute the GCC source.c-o dest to generate the executable file

Finally, enter the generated executable file name to run the generated program.

We recommend that you join the-wall option to open frequently used warnings.

Here are a few common commands:

Compiling C language

Gcc-wall source file name-o executable file name

Compiling the C + + language

g++-wall source file name-o executable file name

Debugging C + +

g++-G source file name-o executable name gdb executable file name

Sublime Text 3 Default C + + compilation configuration file

Once the g++ is added to the environment variable, the default compilation system in sublime can be used normally.

We open a CPP file in sublime Text 3, press Ctrl+b

This is the default C + + Compile command that sublime comes with. The first one is compile, the second one is run. It can be used normally. ( requires restart of Windows after environment variable configuration)

Sublime Text 3 3080 After the revision of the compilation system, the specific settings are

Ctrl+b executes the last compiled command of the modified format. If the first execution prompts you to choose which

Ctrl+shift+b choose which to execute

Deficiencies:

1. The program output is captured in the sublime window, which results in the inability to enter information when it is run. Code that executes a scanf statement will get stuck.

2. C and C + + are not differentiated by default, and are all treated as C + + format.

Solutions

The first is to set the execution program in the new CMD window so that you can enter information.

The second one is to write a build configuration file for the C language separately.

Default compilation configuration file location

In the Packages folder of the sublime installation directory, there is a file called C++.sublime-package

This is actually a zip compression package, which contains the default system settings for C + +, modify the suffix named zip after decompression , you can find in the C + + single File.sublime-build file.

This file name is the name you can choose to compile.

Compiling the configuration file

The contents of this file are as follows:

{
	"shell_cmd": "g++ \"${file}\" -o \"${file_path}/${file_base_name}\"",
	"file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",
	"working_dir": "${file_path}",
	"selector": "source.c, source.c++",
 
	"variants":
	[
		{
			"name": "Run",
			"shell_cmd": "g++ \"${file}\" -o \"${file_path}/${file_base_name}\" && \"${file_path}/${file_base_name}\""
		}
	]
}

This JSON-formatted configuration file is the true face of the build file in sublime. Inside the curly braces are key-value pairs, separated by commas. The middle of the key and value is a colon. For convenience the following keys are called names.

Both the name and the value are enclosed in double quotation marks, so the value inside of the double quotation mark is used as an escape \ "(backslash + double quotation mark).

The name used here has the following meanings:

name	meaning
Working_dir	Running CMD will first switch to the working directory specified by Working_dir
Cmd	Includes commands and their parameters. If you do not specify an absolute path, the external program searches your system's: Const:path environment variable.
Shell_cmd	Equivalent to shell:true cmd, CMD can be run through the shell.
File_regex	This option uses Perl regular expressions to capture the error output of the build system to the sublime window.
Selector	In Selected Tools | Build System | Automatic the system according to this automatic selection.
Variants	Alternative to the main building system. That is, a configuration file can correspond to multiple execution commands
Name	Only under Variants, set the name of the command, such as run.

There are some similar ${file} symbols in the above configuration file, which are the variables provided by sublime, and some commonly used variables are as follows:

variables	meaning
$file _path	The directory path where the current file is located, e.g., C:\Files.
$file	The detailed path to the current file, e.g., C:\Files\Chapter1.txt.
$file _name	Full file name (with extension), e.g., Chapter1.txt.
$file _extension	The current file name extension, e.g. txt.
$file _base_name	Current file name (not including extension), e.g., Document.

The use of variables can be used directly or enclosed in curly braces, such as ${project_name}.

Let's look at this file in detail.

"Working_dir": "${file_path}",

This line describes the working directory, which is the directory where the command is executed, and is set to the directory where the file resides.

The following

"Shell_cmd": "g++ \" ${file}\ "-o \" ${file_path}/${file_base_name}\ "",

This is the command executed at compile time, and the part of its value is

g++ \ "${file}\"-o \ "${file_path}/${file_base_name}\"

When executed, ${file} will be replaced with the edited file name, and ${file_path}/${file_base_name} will be replaced with the full pathname without the extension. They are preceded by a \ "double quotation mark to support file names with spaces.

Assuming that we edit the file path to Z:/cpp/t.cpp, then the working directory at the time of execution is z:/cpp. ${file} is Z:/cpp/t.cpp, ${file_path} is Z:/cpp, ${file_base_name} is T. We put the escape character Fu Di quotation marks in double quotes, so the executed command becomes

g++ "Z:/cpp/t.cpp"-O "z:/cpp/t"

This is exactly the command to compile the file, and the double quotation marks before and after the file path guarantee that it supports paths with spaces. The executable and source code files generated after compilation are in one directory with the same name (different extensions).

If there is a compilation error, the error message is matched and displayed by the regular expression in "File_regex".

And look at the last code.

"variants":
	[
		{
			"name": "Run",
			"shell_cmd": "g++ \"${file}\" -o \"${file_path}/${file_base_name}\" && \"${file_path}/${file_base_name}\""
		}
	]

The value of variants is an array that can put many objects, each representing a command. Inside name indicates that the command is named Run, which is running. Selecting C + + single File-run at compile time will execute the shell_cmd.

The first half of the command in the Run section is the same as the compilation, followed by a && connection with another command,&& indicates that the compilation succeeds before performing the subsequent section. Followed by

\ "${file_path}/${file_base_name}\"

That is to run the executable directly. This is to capture the result of the run in the sublime.

After reading this default profile, divert, it's easy to write a profile that fits your needs.

However, it is not recommended to directly modify this file, we recommend that you put the user configuration under the user folder, instead of the default compilation configuration.

Write your own compilation configuration file C language

Select Tool–> Build system–> New build System

Then enter the following code

"variants":
	[
		{
			"name": "Run",
			"shell_cmd": "g++ \"${file}\" -o \"${file_path}/${file_base_name}\" && \"${file_path}/${file_base_name}\""
		}
	]

Compared to the default, the selector section is modified to select only. c files. in Run, the Shell_cmd is added with the start Cmd/c,start function is a new cmd window, cmd means to execute a command line,/C to exit the new window after execution, after the end of the & pause to ensure that the window will not exit immediately after the run. This will run in the new CMD window.

Press Ctrl+s save, will automatically open the User directory (Sublime Text 3\packages\user), we modified the file name is C.sublime-build, saved in this directory.

At this point, you can see the new C that you just created under Tools--Build system

When selected, it is ready to use.

In addition to selecting a specific compilation system in the build systems, you can also select the first: Automatic automatic selection, which is automatically selected based on the file suffix that is opened. Because the. c file Sublime is recognized as a C + + type by default, you need to modify one point when using automatic selection:

The default is C + + format when opening a. c file with sublime first. (Note: The latest version of 3013 is already in C format, you do not have to modify it)

Click c + + at the red arrow to select Open all with the current extension as. Then select C

This will open the. c file by default to C type

Press Ctrl+shift+b at this time

The third c is the corresponding execution of the third line in the configuration file Gcc-wall $file _name-o $file _base_name function is compiled.

Fourth C-run corresponds to the following command Gcc-wall $file-o $file _base_name && start cmd/c \ "${file_path}/${file_base_name} & Pause\" , the function is to run in a new CMD window. This makes it possible to enter functions such as scanf.

C++

Although GCC can compile C + + code, it cannot do the C + + connection function library operation. So for C + + code generally use g++ to compile.

Method and the above C language configuration, as long as the configuration file in the GCC changed to g++, source.c to source.c++, save the file name C.sublime-build changed to C++.sublime-build.

This adds the-STD=C++11 option, which is compiled according to the C++11 standard, which can be removed if not required, and the configuration file is as follows

{
	"encoding": "utf-8",
	"working_dir": "$file_path",
	"shell_cmd": "g++ -Wall -std=c++11 \"$file_name\" -o \"$file_base_name\"",
	"file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",
	"selector": "source.c++",
 
	"variants": 
	[
		{	
		"name": "Run",
        	"shell_cmd": "g++ -Wall -std=c++11 \"$file\" -o \"$file_base_name\" && start cmd /c \"\"${file_path}/${file_base_name}\" & pause\""
		}
	]
}

In fact, we can use Varians to configure several different compile commands.

The following configuration files are compiled, compiled and run in Sublime, compiled and Cmd run, and gdb debugs four commands.

Note:gdb debugging is the way to open the command line, there is no support for the source code with spaces file name and path,gdb use can refer to: GdB debugging Novice (a) | Aloft. To achieve graphical debugging through the SUBLIMEGDB plug-in, you can refer to sublime Text 3 using sublimegdb graphical Debug/C + + program.

{
	"encoding": "utf-8",
	"working_dir": "$file_path",
	"shell_cmd": "g++ -Wall -std=c++11 \"$file_name\" -o \"$file_base_name\"",
	"file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",
	"selector": "source.c++",
 
	"variants": 
	[
		{	
		"name": "Run in sublime",
        	"shell_cmd": "g++ -Wall -std=c++11 \"$file_name\" -o \"$file_base_name\" && cmd /c \"${file_path}/${file_base_name}\""
		},
		{	
		"name": "CMD Run",
        	"shell_cmd": "g++ -Wall -std=c++11 \"$file\" -o \"$file_base_name\" && start cmd /c \"\"${file_path}/${file_base_name}\" & pause\""
		},
		{	
		"name": "gdb Debug",
        	"shell_cmd": "g++ -g -std=c++11 \"$file\" -o \"$file_base_name\" && start cmd /c gdb ${file_path}/${file_base_name} & pause"
		}
	]
}

Compiling multiple files with makefile

Sublime can use makefile to compile multiple files to support a slightly larger project. (Windows below and Linux below are not the same, this article describes for Windows)

This feature only opens a single file that is not available, only open the entire folder

You can see the open folder in the sidebar to make sure that the folder contains the makefile file. When you press CTRL+SHIFT+B, there is an option to make.

The Make option is done here, but there is no make command in Windows. The name inside the Mingw\bin is Mingw32-make.exe. The workaround is to change the file name to Make.exe, or create a new makefile build file yourself.

The default compilation profile for Makefile is in the "C:\Program files\sublime Text 3\packages\makefile.sublime-package", extracted from the Make.sublime-build file.

We created a new build system,tool–> build system–> New build systems with the contents of

Note: The file is tested in the sublime 3126 version, the lower version may not support the KeyFile keyword, or there is no packages/makefile/make Output.sublime-syntax files, you can upgrade or try to delete these rows

{
	"shell_cmd": "mingw32-make",
	"file_regex": "^(..[^:\n]*):([0-9]+):?([0-9]+)?:? (.*)$",
	"working_dir": "${folder:${project_path:${file_path}}}",
	"selector": "source.makefile",
	"syntax": "Packages/Makefile/Make Output.sublime-syntax",
	"keyfiles": ["Makefile", "makefile"],
 
	"variants":
	[
		{
			"name": "Clean",
			"shell_cmd": "mingw32-make clean"
		},
		{
			"name": "Run",
			"shell_cmd": "mingw32-make run"
		},
	]
}

Save As Mingw32-make.sublime-build, save location and the above C + + configuration file location is the same.

Then open the folder, if there is makefile or makefile file, there will be a corresponding command

Because the common commands under Windows are different from Linux, makefile also makes the corresponding changes:

Makefile Example

The following is a simple example:

Now there is a test folder with 4 files in it

Where Main.cpp used the function in the func.cpp. The specific code is as follows:

Main.cpp

 
#include "func.h" int main()
{
    output(); return 0;
}

Func.h

void output ();

Func.cpp

#include <cstdio> void output()
{
    printf("hello world\n");
}

Makefile

main : main.cpp func.h func.cpp
 
 
clean:
	del main.exe *.o
 
run:
	mingw32-make && start cmd /c "main.exe & pause"

Note: The makefile inside the clean and run, and our own configuration file "variants" under the command Mingw32-make clean and mingw32-make run corresponding.

Clean below use the command for del instead of the RM below Linux

In addition, because there is no CC command under Windows, all dependencies cannot occur here. o the target of the file. For example, there is no such rule:

MAIN:MAIN.O FUNC.O

When you use such a rule, CC is called, but CC is not available under Windows, and you get an error.

Open the folder in sublime text 3 ( Note that you must open the folder, only open the file without the make option)

Then use Ctrl+shift+b to select the corresponding Mingw32-make command.

Run corresponds to compile and run.

The problem of Chinese code garbled

Thank rgb0x000000 for pointing out the problem of Chinese coding. Because the default encoding format for files in Sublime Text 3 is utf-8, the command line default encoding format in Windows is GBK. So the code in Chinese when the run will be garbled.

The solution is also very simple, is to let them code consistent on it.

1. Change the cmd code to Utf-8

Use the CHCP command to view the current character set, which is 936 by default, and you can use CHCP 65001 to modify the character set to Utf-8

However, it seems to be only valid for the currently open window, one troublesome way is to run the system in each code to toggle the character set (POP)

2. Modify the source code format to GBK

Sublime native does not support GBK encoding, but if the ConvertToUTF8 plugin is installed, ANSI or GBK encoded files can be displayed correctly. Therefore, the plug-in after the open GBK encoded source code files, will not garbled.

A more ingenious approach is to use the compiler's option -fexec-charset to set the encoding of the string in the code so that the source file can use Utf-8 encoding, but compiles the string in the source code with the specified encoding.

Add the option -FEXEC-CHARSET=GBK to the compile command GCC to show that the string in the code is encoded in GBK, and that it is consistent with the CMD window and is not garbled.

The configuration file for the modified C language is as follows:

{
	"working_dir": "$file_path",
	"cmd": "gcc -Wall -fexec-charset=GBK \"$file_name\" -o \"$file_base_name\"",
	"file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$",
	"selector": "source.c",
 
	"variants": 
	[
		{	
		"name": "Run",
        	"shell_cmd": "gcc -Wall -fexec-charset=GBK \"$file\" -o \"$file_base_name\" && start cmd /c \"\"${file_path}/${file_base_name}\" & pause\""
		}
	]
}

But after adding this option, if you want to compile not utf-8, but GBK, you must also add the-FINPUT-CHARSET=GBK option to develop the encoding format of the source code, otherwise it will prompt the error

Error:converting to execution character Set:illegal byte sequence.

and add this option after compiling utf-8 will be garbled ... So, at present, Bo Master has not found the source file is Utf-8 encoding and GBK encoding two cases Chinese will not garbled method ...

Transferred from: http://www.yalewoo.com/sublime_text_3_gcc.html

Yalewoo

Sublime Text 3 Configuring the C + + compilation environment (RPM)