In this lecture we are going to cover what you need to know in order to start programming in C/C++ in a Linux environment. We will cover the following:

• 1. Why Program under Linux? (Briefly)
• 2. Use of gcc/g++
  • 2.1. Important gcc Flags
  • 2.2. g++
• 3. Writing Makefiles
  • 3.1. Makefile Basics
  • 3.2. Makefile Variables
  • 3.3. Final Notes
• 4. The Almighty Emacs
  • 4.1. More Emacs
  • 4.2. Yet More Emacs
  • 4.3. Emacs - The End (Well at Least the Last Slide)
• 5. The gdb Debugger
  • 5.1. Basic gdb Commands
• 6. DDD - The Data Display Debugger
  • 6.1. DDD Debugging Tips
• 7. valgrind - a Good Tool to Detect Memory Problems
  • 7.1. More Valgrind

License

This document is Copyright by Meir Maor, 2004, and is available under the terms of the Creative Commons Attribution-ShareAlike License 4.0 Unported (or at your option any later version). Whatever source code is provided is under BSD-3-Clause

Shlomi Fish hereby places his changes under CC-by 4.0-or later with source code changes under BSD-3-Clause.

There are many reasons, the most important IMHO are:

• Stable environment; makes it hard to mess up too badly,
• Good tools, ANSI compliant. Work less and get more done.
• Portable code. What you write using GNU tools will work anywhere.
• A nice little Unix system at home.
• Open source environment.

• gcc is the GNU compiler collection, originally called GNU C compiler.
• gcc is commonly invoked from the command line, like so:
  gcc [ option | filename ]...
  
• This is correct but, probably means nothing to you, one would normally use gcc like so:
  gcc [flags] file1 [file2 [file3 ...]] [-o output_file]
  where file1 file2 etc. are input files, either C source files or pre-compiled object files.
• Example: gcc foo1.c foo2.c -o foo
• The default executable output filename is a.out. When producing object files, the default output for each input file has the suffix .o .

• When compiling, I recommend (and Kimchi demands) compiling with:
  gcc -ansi -pedantic -Wall file1 [file2 [file3...]] -o output

• g++ is actually a script which calls gcc with the appropriate options in order to compile C++. Standard suffixes for C++ source files are: .C, .cc, .cxx, .cpp, or .c++.
• I recommend using g++ like so:
  g++ -Wall file1 [file2 [file3...]] -o output_file

• Makefiles are a way to define how your project is to be built.
• The make tool reads this file and compiles your project properly and efficiently, recompiling files that were changed and files which depend on them using the correct compile command at each stage.
• For large projects this is a must, and in many cases it is convenient also for small projects with only half a dozen source files.

• A makefile is built out of a set of targets which we want to build and intermediate targets used in the build process.
• In a makefile, the target is followed by a colon (:), which is then followed by a list of its dependent targets or files (commonly referred to as dependencies). Afterwards in a new line, there should be a tab character (and not any other whitespace before or afterwards), followed by the command used to generate the target from the dependencies.

Example

foo: foo.o helper.o
    gcc -Wall foo.o helper.o -o foo

bar: bar.o helper.o
    gcc -Wall bar.o helper.o -o bar

bar.o: bar.c
    gcc bar.c -c -o bar

foo.o: foo.c foo.h
    gcc -ansi -Wall -c foo.c -o foo.o

• To run make one types: make [target_name]
• If no target is specified the first target in the makefile is used.

• We can define variables in makefiles to make the writing shorter and the modifications easier.
• Rewriting the previous makefile with variables and extra targets:

CC= gcc
LD= gcc
CC_FLAGS = -ansi -Wall -c
LD_FLAGS = -Wall

all: foo bar

foo: foo.o helper.o
    $(LD) $(LD_FLAGS) foo.o helper.o -o foo
bar: bar.o helper.o
    $(LD) $(LD_FLAGS) bar.o helper.o -o bar

bar.o: bar.c
    $(CC) $(CC_FLAGS) bar.c
foo.o: foo.c foo.h
    $(CC) $(CC_FLAGS) foo.c

clean: rm -f *.o foo bar

How Make Works

• Makefiles watch the time-stamps for files, if the source files time stamps are newer than the target, the target needs to be rebuilt and any targets depending on it need to be rebuilt as well.

More Information

• More information on makefiles can be found in the info file, accessible via the pinfo make command, or by typing: info:make in the Konqueror address line.

• Emacs is my recommended editor. There are some who prefer VI. IMHO they tend to be masochistic.
• First of all, Emacs like everything under linux has good documentation. When you run emacs type C-h t (that is Control+h and then t), and you will get to an emacs tutorial (that can also be found in the help menu)
• emacs usually allows moving around using the arrow keys and page_up/down keys but it always allows another better way which does not involve moving your fingers from the normal typing position. It will take getting use to but eventually will work much faster.
• Basic movement with the arrow keys can be replaced with:

• One could also use M-f and M-b to move one word at a time instead of one character at a time.
• M is short for the Meta key, on your keyboard it will probably be Alt.
• Page up is M-v. Page Down is C-v.
• End of Line is C-e. Beginning of the Line is C-a.
• So much for moving around.
• The most common method of copy&paste is by cutting out using C-k. C-k cuts until the end of line, typing C-k many times will cut many lines. If you cut a few lines then move around and cut more lines. The first lines would be lost this way (not including possible undo).
• In order to paste we will yank the text out of the buffer using C-y you can yank(paste) out however many times you want wherever you want.

• At this point we should mention C-x u which is the undo option it will undo the last act. You can do several of these in a row, notice there is a big difference between C-x u and C-x C-u you must let go of the Ctrl key, before hitting the u key.
• Handling files and buffers can be done with menus on top but also with shortcuts: opening a file is with C-x C-f you can use the tab to complete file names as you can in the bash/tcsh command prompt.
• When executing emacs from the command line you can give it a file name as a parameter, in both cases emacs will create a new file should the file not exist.
• Saving is done by C-x C-s which saves the current buffer(file) or C-x s which will prompt to verify and save each and every open buffer.
• One exits emacs with C-x C-c.

• Basic search in emacs is done with C-s.
• Search and replace is done with M-%.
• Emacs does syntax highlighting. You can easily enable this by selecting it in the Options menu.
• Emacs will align your source code automatically. You can use the tab key to re-align a specific line. Always re-align from top to bottom.
• You can recompile your code while inside Emacs. Type M-x compile. A new buffer will open and it will display compilation results. You can go through them easily while having your cursor jump to where the errors are using C-x `. (backquote).
• To maximize the current buffer to cover all of the Emacs window use C-x 1, (C-x 2 will split the buffer)
• We will look at a little example program that we will edit & compile with Emacs: test.c.
• A useful time saver: expand abbreviations with M-/.

• gdb is the basic debugger. Many Linux debuggers are based on it.
• Even though it does not have a fancy GUI, it does the trick.
• In order to use gdb one must use the -g flag when compiling!
• Executing gdb is simple: gdb program_name (it can be run differently but for that RTFM)
• gdb has an excellent built in help, you can type help from the gdb command line and get a list of stuff to get help on, or type help <something>, and get specific help on something - either a command or a topic name.
• Another good source for help on gdb is the info pages. Type: pinfo gdb or info gdb if pinfo is not available.

• And many more (see the help).

• DDD is a powerful tool which is a graphical interface for an inferior debugger (usually gdb). DDD can do everything your favourite debugger can and much more.
• You can watch the code and execute it line by line and examine data.
• The speciality of DDD as its name might suggest is its ability to display your programs data graphically in a very comfortable manner.
• DDD will allow you to display structures and dereference pointers to create a visualization of a linked-list or a tree. DDD can also create graphs out of arrays.
• DDD has a gdb command line, so anyone who can use gdb can use DDD and gradually learn its special features.
• A little test program: testddd.c.

• Right click with mouse to the left of code to add/remove breakpoints.
• All gdb commands work from gdb window at bottom of screen.
• When program crashes, first look at stack back-trace,by choosing <menu>->Status->Backtrace.
• To display data structures use display section, right-click on a variable and choose display.
• In display section, double click on a pointer to dereference it.
• To have DDD detect the same object is being referenced from two places, type Alt-a. Or <menu>->Data->Detect Aliases. In the latest version, this is default behaviour.
• When debugging C++, to avoid stepping into STL functions, one should normally use Next; use Step when you specifically want to step into a function.
• Place mouse over a variable to see its value.

• valgrind can detect problems such as:
  
  • Use of uninitialized memory.
  • Reading/writing memory after it has been free'd.
  • Reading/writing off the end of malloc'd blocks.
  • Reading/writing inappropriate areas on the stack.
  • Memory leaks -- where pointers to malloc'd blocks are lost forever.
  • Passing of uninitialized and/or unaddressable memory to system calls.
  • Mismatched use of malloc/new/new [] Vs free/delete/delete [].
  • Some abuses of the POSIX pthreads API.
• valgrind is very easy to use. It has many optional flags that you can learn about from the documentation. (valgrind -h).
• A useful flag is --num-callers=NNN which sets how far back to print the function call sequence when an error is detected, (sometimes the error actually occurs in a sequence of functions you didn't write). By default it is --num-callers=4.

• Valgrind does not require special compilation. You simply execute it like so: valgrind --num-callers=15 progname. It will run the program progname and intercept calls to malloc/free/new/delete and monitor all memory uses.
• Another useful flag is --gdb-attach=yes that invokes gdb on the process when errors are detected, and let you debug the place of the error.
• Valgrind is good only for x86s running some non-ancient Linux - this shouldn't be much of a problem.
• Valgrind will report several types of errors:
  • Illegal read / illegal write errors.
  • Use of uninitialized values.
  • Illegal frees.
  • Inappropriate deallocation function.
  • Passing system call parameters with inadequate read/write permissions.
• Valgrind will tell you, when possible, where in your code the relevant memory blocks were allocated/freed.
• Valgrind is most probably not installed on the Linux box you are working on, however installation is trivial and fairly quick: download, unpack and then run one after another:
  ./configure
make
make install
  
• Valgrind's manual is available in the distribution directory under docs/index.html.