Computational Geometry (Fall 2006)

Hints for use of C++ and other development tools at DAIMI

Contents

• The C++ compiler.
  • Simple compilation of a C++ program.
  • How to run the program.
  • Conditional compilation.
• Getopt.
• Debugging.
  • Assertions.
• Make.
  • More about Make.
• Reading the manual.
• Includes and linkning.
  • The compilation process.
• The Standard Template Library.
• Special C++ considerations.
• Version control and file sharing.
  • How to get started with CVS?.

One of the advantages of the g++ compiler is that it exists on all the DAIMI Unix machines and behaves the same on all the platforms. Much documentation about g++ exists in the Emacs info system (choose "browse manuals" in the Emacs help menu).

Simple compilation of a C++ program

	g++ -Wall -g program.cpp -o program

This compiles the C++ program in program.cpp into executable code in the file program. The command line options means the following:

-Wall:

Read -W all, i.e., ask g++ to generate lots of warnings about coding style etc. This helps to find bug, eg. using = where == is meant, use of uninitialized variables and much more. Reading and getting rid of these warnings can save hours of debugging later on.

-O:

Optimize. Generates better code, also makes more warnings possible. More optimization can be turned on by -O2.

On the other hand, -O can confuse gdb during debugging...

-g:

Generate debugging information. This is necessary for later debugging the program with gdb, ddd, xdb, xdbx or other debuggers.

-frepo:

Generate template code repository (.rpo) files. This can be an advantage in larger projects with many .cpp files. The -frepo option keeps track of where template code is instantiated, such that a specific instance is present only once in the final program.

-o program:

Place the compiled program in the file "program" instead of in "a.out" which is the default.

Remember

	./program

	program

Many beginning Unix programmers have burnt their fingers by typing

	test

and finding that this didn't work as they expected, as this command usually executes the program /bin/test and not the program in the current directory.

Conditional compilation

	g++ ... -DFOO ... pgm.cpp

	g++ -DDEBUGLEVEL=7 ...

#if DEBUGLEVEL > 4
 ....
#endif

When debugging it may be a good idea to have a run-time variable deciding how much debug info the program should print out. One example could be:

int
func(double x)
{
#ifdef DEBUG
	if(debuglevel > 0) {
		printf("entered func\n");
	}
	if(debuglevel > 3) {
		printf("x = %f\n", x);
	}
#endif
	...
}

Getopt

#include <getopt.h>

int main(int argc, char *argv[]) {
        int ch;
        ...
        while ((ch = getopt(argc, argv, "x:f"))) {
                switch (ch) {
                case 'x':
                        /* option -x was used */
                        printf("argument = %s\n", optarg);
                        break;
                case 'f':
                        /* option -f */
                        break;
                default:
                        /* error */
                        break;
                }
        }
}

	M-x gdb

Emacs then asks for the name of the program that you want to debug. It should have been compiled with the -g option as described above. Emacs opens a buffer called *gud-...* (for Grand Unified Debugger). You may now set break-points in the program and run it under gdb. See how to use the gdb from within Emacs in the Help menu (Describe mode).

Here is a small sample of common gdb commands:

C-x space

on a line in the source code sets a break point.

r [arguments]

Starts the program with the given arguments.

p <variable>

Prints the value of a program variable.

s

Single step.

n

Next instruction.

bt

Prints the call-stack (back trace).

q

Quit.

Gdb can do much more, and is described in the Emacs info system (C-h i) or choose "browse manuals" from the Help menu.

Assertions

In the beginning of your code you include assert.h:

#include <assert.h>

int
foo(int n)
{
	assert(n > 0);

	... bla bla ...
}

At run-time the assert() macro checks that n is positive, and if not the program aborts with an error message and a core dump that can be used to find the error:

Assertion failed: n > 0 at line 545 in "program.c"

It is good practice to have assertions checking the pre-conditions of all parameters to all functions in your program. Real consistency-check routines may also come in handy if you have complicated data structures with invariants that need to be maintained!

It is important not to change the state of you program within the assert macros. The assertions can be switched off at compile time (with -DNDEBUG) when you are sure that the program works, and the assertions will then not be included in the program. Statements like:

  assert(n = 0);

Make

Makefiles specify dependencies and how to get from source files to the finished executable.

Here is a simple Makefile. You may copy it from this template.

# Comments are nice
# Here a macro definition specifying the source files
SRC	=	modula.cpp modulb.cpp main.cpp
# another macro, as SRC, but replace .cpp by .o
OBJ	=	$(SRC:.cpp=.o)
CC	=	g++
CFLAGS	=	-Wall -O -g

# Here is the rule of how to get from a .cpp file to a .o file:
# The $< macro expands into a source file name
.cpp.o:
	$(CC) $(CFLAGS) -c $<

# a dependency: to make the target "all", first do the target "pgm"
all:	pgm

# another dependency: to make the target pgm, make the files that OBJ
# expands to, here "modula.o modulb.o main.o", then link the object
# files with the $(CC) command into the executable pgm
pgm:	$(OBJ)
	$(CC) $(OBJ) -o pgm

# How does make find out how the $(OBJ) object files are made? It has
# default rules for this, eg. the .cpp.o rule above.

Note

Commands in Makefiles start with a TAB character, not spaces, but ASCII 9. That is, the first character in the line $(CC) $(OBJ) -o pgm above is a TAB character. If you paste from an xterm into emacs, then TABs will be converted into spaces and the make commands will not work. You may recognize a TAB character in emacs when the cursor jumps from the start of the line to the first $ character in one jump when you use the cursor keys.

You will often need more advanced dependencies among files. For example if modulea.h contains definitions that are used (#included) in both modulea.cpp and moduleb.cpp; when modulea.h changes then both modulea.cpp and moduleb.cpp need to be recompiled. You may use gcc to find these dependencies:

At the end of the above Makefile you append the following line:

include dependencies

You now execute the following command whenever you change includes in you programs:

	gcc -MM *.cpp > dependencies

To re-compile your entire program complex you now just write:

	make

Make from within Emacs

	M-x compile

	man 3 <name of function>

	man -k <keyword>

GCC, gdb, and many other tools are described in the Emacs info system. Choose "browse manuals" from the help menu or enter info-mode using "C-h i".

Include files

#include <stdio.h>

#include "foobar.h"

A couple of things that the fresh C++ programmer should know: You do NOT use include files to divide your code into smaller parts. You do NOT include .cpp or .c files. You include .h files with common type definitions, constants and prototypes in a number of .cpp files that are then compiled separately and linked together at last. See below.

The compilation process

The figure below illustrates how a program consisting of two modules p1.cpp and p2.cpp are compiled and linked into a executable program a.out.

p1.cpp ---> CPP ---> CC1plus ---> AS ---> p1.o
  			                     \__ LD ---> a.out
			                     /
p2.cpp ---> CPP ---> CC1plus ---> AS ---> p2.o

CC1plus is the real C++ compiler which translates from C++ to assembly. AS is the assembler compiling symbolic assembly into binary code in the .o object file.

The linker LD takes the object files which may refer to each other to various libraries and links them together into the final executable. Nowadays the libraries are seldom linked into the executable, only a stub is linked in and the real library is dynamically linked in when the program is started.

G++ (and CC) is a front end to all of this process. G++ knows, for example, that it need only run the linker on a set of .o files. The -c option to G++ tells it to stop before the link phase.

Standard Template Library

Here is a small example of using a STL map which is implemented by a red-black tree:

#include <string>
#include <map>

using namespace std; // the STL types are in the std namespace

typedef map<string, int> StringMap;
StringMap months;

months[string("January")] = 31;
months[string("February")] = 28;
months[string("March")] = 31;
months[string("April")] = 30;
...

Special C++ considerations

• Operator overloading: Don't use it unless you are really implementing a mathematical ring, field or something similar. In that case implement the operators fully. Use the binary operators for +, - etc. It is very annoying to have "c = a+b" modify a... Your code can become very unreadable if you gratuitously overload operators with non-intuitive functionality.
• Method overloading: Use it sparingly with constructors, because there may be no other way. Otherwise, just find another name for the new method.
• Default parameter values: They are useful to keep old code working when you just need an extra parameter to a method in certain circumstances. Otherwise, don't use it: you tend to forget what the defaults are...
• Special memory allocators: Don't use then unless you really, really must.
• Templates: Use the STL data types and algorithms. Writing your own template classes and functions can be tricky and hard to debug.
• Exceptions: Use them sparingly, and only for REALLY exceptional conditions. Throw an exception only for conditions where the typical program using the function would just exit with an error message. Otherwise you will find your programs littered with exception handling code.
• References: In C++ reference types are like pointers except that the pointer-ness cannot be seen at the point of use. I use them often to pass parameters by reference but only when I don't modify the parameter, that is declare a method:

  int
  MyClass::f(const OtherClass& obj)
  {...}
  

  and not:

  int
  MyClass::f(OtherClass& obj)
  {...}
  

	cvs update file.c

	cvs commit file.c

	cvs update

The only commands frequently used are "cvs update" and "cvs commit". "cvs diff" may also be useful to see the changes made between different versions.

CVS means Concurrent Version System, and builds on top of RCS (Revision Control System).

How to get started?

	cvs -d /users/XXXX/project/repository init

In their .login file each group member should have a line like:

	setenv CVSROOT /users/XXXX/project/repositotry
			      ^^^ replace by suitable user name

	cd .../examples/		<--- for instance
	cvs import ex1 foo bar

You may now check out the module from CVS by:

	cd /somewhere/else
	cvs checkout ex1

In order for this to work for all members of a group, the keeper of the repository should give permission to read and write the repository to the group members.

New files are added to the repository by

	cvs add fil2.c

Peter Ørbæk, poe@daimi.au.dk, August 2001
Modified by Gerth Stølting Brodal, gerth@cs.au.dk, September 2004