GCC - Revision history

Techbot at 11:15, 20 September 2022

2022-09-20T11:15:24Z

← Older revision		Revision as of 13:15, 20 September 2022
Line 643:		Line 643:
	./main		./main

	~~You should be able to see the output of the executable program at your console.~~
	~~3. Conclusion~~

	~~Let’s recap on what we have learned today.~~

	~~We started off with installing~~ a ~~compiler for our project~~. In ~~this case, I have installed Microsoft~~ Visual Studio ~~Community 2017 with the Visual C++ extension~~.		.a are static libraries. If you use code stored inside them, it's taken from them and embedded into your own binary. In Visual Studio, these would be .lib files.

	~~Next~~, ~~we wrote some code in C++ that served as the base functionality for our shared library~~. ~~After that~~, ~~we compiled~~ the code ~~into a dll and built an executable~~ from ~~it. We ran the program inside the terminal to test out~~ the ~~functionality which was working as expected~~.		.so are dynamic libraries. If you use code stored inside them, it's not taken and embedded into your own binary. Instead it's just referenced, so the binary will depend on them and the code from the so file is added/loaded at runtime. In Visual Studio/Windows these would be .dll files (with small .lib files containing linking information).

	~~Besides, I have provided a complementary explanation on how to compile in Linux which might~~ be ~~useful for those intend to build shared libraries in Linux platform~~.

Techbot: /* Include Files */

2021-09-17T07:59:28Z

Include Files

← Older revision		Revision as of 09:59, 17 September 2021
Line 270:		Line 270:

	This is a clumsy way to go about declaring functions that are implemented in a separate file.		This is a clumsy way to go about declaring functions that are implemented in a separate file.
	Suppose that there are lots of programs that would like to use the functions contained in ``help.c''. For every program, we are going to have to remember to copy the function headers from ``help.c'' as function declarations. This is a tedious and error prone procedure.		Suppose that there are lots of programs that would like to use the functions contained in ``help.c''. For every program, we are going to have to remember to copy the function headers from ``help.c'' as function declarations. This is a tedious and error prone procedure.

	Once we have copied over the headers, we will have multiple copies of the same information. The declaration of the functions appear in the using file (in our case, ``main.c''), while the implementations are somewhere else. What might happen as we begin to change the two programs? Over time, if we're not careful, the declarations in ``main.c'' may become different from the headers in ``help.c''. At that point, our declarations will be worse than useless-they'll be wrong!		Once we have copied over the headers, we will have multiple copies of the same information. The declaration of the functions appear in the using file (in our case, ``main.c''), while the implementations are somewhere else. What might happen as we begin to change the two programs? Over time, if we're not careful, the declarations in ``main.c'' may become different from the headers in ``help.c''. At that point, our declarations will be worse than useless-they'll be wrong!
Line 276:		Line 276:
	Here's how we can deal with both of these problems. Create a new file that contains nothing but the declarations of the functions in ``help.c''. In fact, we have already created just such a file:		Here's how we can deal with both of these problems. Create a new file that contains nothing but the declarations of the functions in ``help.c''. In fact, we have already created just such a file:
	help.h		help.h
	~~<nowiki>~~
	/* Header file for "help.c"		/* Header file for "help.c"
			Created: Joe Zachary, October 22, 1992
	Created: Joe Zachary, October 22, 1992		Modified:
	Modified:		*/
			/* Requires that "n" be positive. Returns the sum of the
	*/


	/* Requires that "n" be positive. Returns the sum of the
	first "n" integers. */		first "n" integers. */
			int sum (int n);
	int sum (int n);		/* Requires that "n" be positive. Returns the product of the


	/* Requires that "n" be positive. Returns the product of the
	first "n" integers. */		first "n" integers. */
			int product (int n);
	int product (int n);
	~~</nowiki>~~



	Along with each declaration, we include some comments explaining what the function does. The idea is that this file is all a programmer needs to look at to use the functions in ``help.c''. The programmer will need to look at ``help.c'' only if he or she is interested in how the functions are implemented.		Along with each declaration, we include some comments explaining what the function does. The idea is that this file is all a programmer needs to look at to use the functions in ``help.c''. The programmer will need to look at ``help.c'' only if he or she is interested in how the functions are implemented.

Techbot: /* Compiling C and C++ Programs */

2021-09-17T07:07:52Z

Compiling C and C++ Programs

← Older revision		Revision as of 09:07, 17 September 2021
Line 60:		Line 60:
	g++ -g -Wall myprog.C -o myprog		g++ -g -Wall myprog.C -o myprog

	= Compiling C and C++ Programs =		== Compiling C and C++ Programs =+

	gcc is the GNU C Compiler and g++ is the GNU C++ compiler. Below are several examples that show how to use g++ to compile C++ programs.		gcc is the GNU C Compiler and g++ is the GNU C++ compiler. Below are several examples that show how to use g++ to compile C++ programs.

Techbot: /* Frequently used compilation options */

2021-09-17T07:07:14Z

Frequently used compilation options

← Older revision		Revision as of 09:07, 17 September 2021
Line 59:		Line 59:

	g++ -g -Wall myprog.C -o myprog		g++ -g -Wall myprog.C -o myprog

			= Compiling C and C++ Programs =

			gcc is the GNU C Compiler and g++ is the GNU C++ compiler. Below are several examples that show how to use g++ to compile C++ programs.
			Example 1: Compiling a simple program
			Consider the following example: Let "hello.C" be a file that contains the following C++ code.

			#include "iostream.h"
			int main()
			{
			cout << "Hello\n";
			}
			== standard way ==
			The standard way to compile this program is with the command

			g++ hello.C -o hello

			This command compiles hello.C into an executable program named "hello" that you run by typing './hello' at the command line. It does nothing more than print the word "hello" on the screen.
			Alternatively, the above program could be compiled using the following two commands.

			g++ -c hello.C
			g++ hello.o -o hello

			The end result is the same, but this two-step method first compiles hello.C into a machine code file named "hello.o" and then links hello.o with some system libraries to produce the final program "hello". In fact the first method also does this two-stage process of compiling and linking, but the stages are done transparently, and the intermediate file "hello.o" is deleted in the process.

			== optimized code ==
			Generate optimized code on a Linux machine.

			g++ -O myprog.C -o myprog

			Compile myprog.C when it contains Xlib graphics routines.

			g++ myprog.C -o myprog -lX11

			If "myprog.c" is a C program, then the above commands will all work by replacing g++ with gcc and "myprog.C" with "myprog.c". Below are a few examples that apply only to C programs.

			Compile a C program that uses math functions such as "sqrt".

			gcc myprog.C -o myprog -lm

			== electric fence ==
			Compile a C program with the "electric fence" library. This library, available on all the Linux machines, causes many incorrectly written programs to crash as soon as an error occurs. It is useful for debugging as the error location can be quickly determined using gdb. However, it should only be used for debugging as the executable myprog will be much slower and use much more memory than usual.

			gcc -g myprog.C -o myprog -lefence

			== Multiple source files ==
			Compiling a program with multiple source files
			If the source code is in several files, say "file1.C" and "file2.C", then they can be compiled into an executable program named "myprog" using the following command:

			g++ file1.C file2.C -o myprog

			The same result can be achieved using the following three commands:

			g++ -c file1.C
			g++ -c file2.C
			g++ file1.o file2.o -o myprog

			The advantage of the second method is that it compiles each of the source files separately. If, for instance, the above commands were used to create "myprog", and "file1.C" was subsequently modified, then the following commands would correctly update "myprog".

			g++ -c file1.C
			g++ file1.o file2.o -o myprog

			Note that file2.C does not need to be recompiled, so the time required to rebuild myprog is shorter than if the first method for compiling myprog were used. When there are numerous source file, and a change is only made to one of them, the time savings can be significant. This process, though somewhat complicated, is generally handled automatically by a makefile.

	= Separate Compilation Tutorial =		= Separate Compilation Tutorial =

Techbot: /* Compiling C and C++ Programs */

2021-09-17T07:06:48Z

Compiling C and C++ Programs

← Older revision		Revision as of 09:06, 17 September 2021
Line 601:		Line 601:

	Besides, I have provided a complementary explanation on how to compile in Linux which might be useful for those intend to build shared libraries in Linux platform.		Besides, I have provided a complementary explanation on how to compile in Linux which might be useful for those intend to build shared libraries in Linux platform.

	~~= Compiling C and C++ Programs =~~

	~~gcc is the GNU C Compiler and g++ is the GNU C++ compiler. Below are several examples that show how to use g++ to compile C++ programs.~~
	~~Example 1: Compiling a simple program~~
	~~Consider the following example: Let "hello.C" be a file that contains the following C++ code.~~

	~~#include "iostream.h"~~
	~~int main()~~
	{
	~~cout << "Hello\n";~~
	}
	~~== standard way ==~~
	~~The standard way to compile this program is with the command~~

	~~g++ hello.C -o hello~~

	~~This command compiles hello.C into an executable program named "hello" that you run by typing './hello' at the command line. It does nothing more than print the word "hello" on the screen.~~
	~~Alternatively, the above program could be compiled using the following two commands.~~

	~~g++ -c hello.C~~
	~~g++ hello.o -o hello~~

	The end result is the same, but this two-step method first compiles hello.C into a machine code file named "hello.o" and then links hello.o with some system libraries to produce the final program "hello". In fact the first method also does this two-stage process of compiling and linking, but the stages are done transparently, and the intermediate file "hello.o" is deleted in the process.

	~~== optimized code ==~~
	~~Generate optimized code on a Linux machine.~~

	~~g++ -O myprog.C -o myprog~~

	~~Compile myprog.C when it contains Xlib graphics routines.~~

	~~g++ myprog.C -o myprog -lX11~~

	~~If "myprog.c" is a C program, then the above commands will all work by replacing g++ with gcc and "myprog.C" with "myprog.c". Below are a few examples that apply only to C programs.~~

	~~Compile a C program that uses math functions such as "sqrt".~~

	~~gcc myprog.C -o myprog -lm~~

	~~== electric fence ==~~
	Compile a C program with the "electric fence" library. This library, available on all the Linux machines, causes many incorrectly written programs to crash as soon as an error occurs. It is useful for debugging as the error location can be quickly determined using gdb. However, it should only be used for debugging as the executable myprog will be much slower and use much more memory than usual.

	~~gcc -g myprog.C -o myprog -lefence~~

	~~== Multiple source files ==~~
	~~Compiling a program with multiple source files~~
	~~If the source code is in several files, say "file1.C" and "file2.C", then they can be compiled into an executable program named "myprog" using the following command:~~

	~~g++ file1.C file2.C -o myprog~~

	~~The same result can be achieved using the following three commands:~~

	~~g++ -c file1.C~~
	~~g++ -c file2.C~~
	~~g++ file1.o file2.o -o myprog~~

	The advantage of the second method is that it compiles each of the source files separately. If, for instance, the above commands were used to create "myprog", and "file1.C" was subsequently modified, then the following commands would correctly update "myprog".

	~~g++ -c file1.C~~
	~~g++ file1.o file2.o -o myprog~~

	Note that file2.C does not need to be recompiled, so the time required to rebuild myprog is shorter than if the first method for compiling myprog were used. When there are numerous source file, and a change is only made to one of them, the time savings can be significant. This process, though somewhat complicated, is generally handled automatically by a makefile.

Techbot: /* Dynamic-link libraries */

2021-09-16T09:40:11Z

Dynamic-link libraries

← Older revision		Revision as of 11:40, 16 September 2021
Line 518:		Line 518:
	You can find a newly created file called app.obj inside the obj folder.		You can find a newly created file called app.obj inside the obj folder.

	== Dynamic-link libraries ==		=== Dynamic-link libraries ===

	The next step is to link it and create a shared libraries. At the command prompt, run the following command.		The next step is to link it and create a shared libraries. At the command prompt, run the following command.

Techbot: /* CREATING AND USING YOUR OWN LIBRARY CODE */

2021-09-16T09:39:10Z

CREATING AND USING YOUR OWN LIBRARY CODE

← Older revision		Revision as of 11:39, 16 September 2021
Line 404:		Line 404:
	The resulting a.out out will contain machine code for all the functions defined in test.c plus any mylib library functions that are called by the test.c code.		The resulting a.out out will contain machine code for all the functions defined in test.c plus any mylib library functions that are called by the test.c code.

	=== RUNNING ===		== RUNNING ==
	an executable linked with a shared object file:		an executable linked with a shared object file:
	If the shared object file in not in /usr/lib, then you need to set your LD_LIBRARY_PATH environment variable so that the runtime linker can find and load your .so file into the executable at runtime:		If the shared object file in not in /usr/lib, then you need to set your LD_LIBRARY_PATH environment variable so that the runtime linker can find and load your .so file into the executable at runtime:

Techbot: /* Separate Compilation Tutorial */

2021-09-16T09:37:14Z

Separate Compilation Tutorial

← Older revision		Revision as of 11:37, 16 September 2021
Line 64:		Line 64:
	All of the programs that we have looked at to this point have been contained within a single file. This is the exception rather than the rule. As programs become larger, it is important to spread them across files of a reasonable size. In this lesson we will look at why this is important, and how it can be done.		All of the programs that we have looked at to this point have been contained within a single file. This is the exception rather than the rule. As programs become larger, it is important to spread them across files of a reasonable size. In this lesson we will look at why this is important, and how it can be done.

	== Compiling Files ==		=== Compiling Files ===

	Up to this point, whenever you wanted to compile a program you compiled the file		Up to this point, whenever you wanted to compile a program you compiled the file

Techbot: /* Linking with libraries: */

2021-09-16T09:35:28Z

Linking with libraries:

← Older revision		Revision as of 11:35, 16 September 2021
Line 59:		Line 59:

	g++ -g -Wall myprog.C -o myprog		g++ -g -Wall myprog.C -o myprog

	~~== Linking with libraries: ==~~
	#

	~~Use the -l option to pass the library name:~~

	~~g++ main.cpp -lpcre2-8~~
	~~#pcre2-8 is the PCRE2 library for 8bit code units (UTF-8)~~

	~~If the library is not in the standard library path, add the path with -L option:~~

	~~g++ main.cpp -L/my/custom/path/ -lmylib~~

	~~Multiple libraries can be linked together:~~

	~~g++ main.cpp -lmylib1 -lmylib2 -lmylib3~~

	~~If one library depends on another, put the dependent library before the independent library:~~

	~~g++ main.cpp -lchild-lib -lbase-lib~~

	~~Or let the linker determine the ordering itself via --start-group and --end-group (note: this has significant performance cost):~~

	~~g++ main.cpp -Wl,--start-group -lbase-lib -lchild-lib -Wl,--end-group~~

	= Separate Compilation Tutorial =		= Separate Compilation Tutorial =

Techbot: /* Example */

2021-09-16T09:33:48Z

Example

@@ Line 43: / Line 43: @@
 Note that due to bugs in GCC, the -pthread flag must be present at compilation and linking for GCC to support the C++ standard threading functionality introduced with C++11, such as std::thread and std::wait_for. Omitting it when using threading functions may result in no warnings but invalid results on some platforms.
 == Linking with libraries: ==
+#