Navigating the C++ Development Environment Two views of the development environment Graphical (stay in this mode whenever possible) Text based (also good to understand this well) We’ll look first at the text based mode Open ssh client, log into grid, get a text terminal window Create a subdirectory called cse232, open up sftp client We’ll work mainly in the nicer graphical environment later Use the Linux manual pages to look up information man <subject> Look up the following: cd ls mkdir find grep And now you know how to look up info on any command Don’t forget about www.google.com

Writing a CSE 232/332 C++ Program emacs Makefile (ASCII text) editor 1 source file = 1 compilation unit C++ source files (ASCII text) .cc Also: .C .cxx .cpp Programmer (you) Also: .H .hxx .hpp C++ header files (ASCII text) .h readme (ASCII text)

What Goes Into a C++ Program? Declarations: data types, function signatures, classes Allows the compiler to check for type safety, correct syntax Usually kept in “header” (.h) files Included as needed by other files (to keep compiler happy) class Simple { public: typedef unsigned int UINT32; Simple (int i); void print_i (); void usage (); private: int i_; }; Definitions: static variable initialization, function implementation The part that turns into an executable program Usually kept in “source” (.cc) files void Simple::print_i () { cout << “i_ is ” << i_ << endl; } Directives: tell compiler (or precompiler) to do something More on this later

Lifecycle of a CSE 232/332 C++ Program e-mail files you wrote (and any we provided) by due date/time xterm console/terminal Makefile make make turnin mail “make” utility Runtime/utility libraries (binary) .lib .a .so debugger make Eclipse Programmer (you) C++ source code g++ precompiler gcc link compiler linker executable program compiler object code (binary, one per compilation unit) .o

A Very Simple C++ Program #include <iostream> // precompiler directive using namespace std; // compiler directive /* definition of function named “main” */ int main (int, char *[]) { cout << “hello, world!” << endl; return 0; } comments

Download hello.cc to desktop, upload it to grid Let’s Build and Run It! Download hello.cc to desktop, upload it to grid First, we need to compile the program g++ -Wall -W -g -c -o hello.o hello.cc Then we need to link the compiled code g++ -o hello -Wall -W -g hello.o Then we can run the program ./hello

Ok, but that was rather Annoying! Typing that in each time you want to compile is a “do once” idea Can use the shell (for example, bash) to automate Put the following lines into a file called build.sh (or even better download and upload from web to grid) #!/bin/bash g++ -Wall -W -g -c -o hello.o hello.cc g++ -o hello -Wall -W -g hello.o Then, make the file executable and run it chmod u+x build.sh ./build.sh

A Better Way: the make Utility Controls the build process Enforces dependencies If something changes, update what depends on it (e.g., object files depend on header and body files) Relies on file update times Can “touch” a file to set its time stamp to now touch Calculator.cc Builds targets First one declared in Makefile is the default Usually want to have this one build the executable file Can build other targets: (the first two get rid of unwanted files) make clean make realclean make turnin

Exercise: Fill in the Example Makefile Get from web, to grid Makefile variables are called “macros” E.g., CMPL_SRCS and EXECUTABLE Some variables can be calculated E.g., OBJS Make infers need to build object files and the executable file Based on timestamps Chains through the dependencies Note: indented lines must start with tabs CMPL_SRCS = main.cc Calculator.cc Trace.cc EXECUTABLE = calc_test OBJS = $(CMPL_SRCS:.cc=.o) $(EXECUTABLE): $(OBJS) g++ -o $(EXECUTABLE) -Wall -W -g -DUNIX $(OBJS) clean: -rm -f *.o core *.bak *~ .cpp.o: $(COMPILE.cc) -Wall -W -g -DUNIX $(OUTPUT_OPTION) $<

Back to the Simple C++ Program #include <iostream> // precompiler directive using namespace std; // compiler directive /* definition of function named “main” */ int main (int, char *[]) { cout << “hello, world!” << endl; return 0; }

#include <iostream> #include tells the precompiler to include a file Usually, we include header files Contain declarations of structs, classes, functions <iostream> is the C++ label for a standard header file for input and output streams What would happen if we didn’t have it? Exercise: try commenting it out, then rebuild…

C++ provides such a namespace for its standard library using namespace std; The using directive tells the compiler to include code from libraries that have separate namespaces C++ provides such a namespace for its standard library cout, cin, and cerr standard iostreams, and much more Namespaces reduce collisions between symbols If another library defined cout we could say std::cout Can also apply using more selectively: E.g., just using std::cout What would happen if we didn’t have it? Exercise: try commenting it out, then rebuild…

What is int main (int, char*[]) { ... } ? Defines the main function of any C++ program Who calls main? The runtime environment, specifically often a function called crt0 What about the stuff in parentheses? A list of types of the input arguments to function main With the function name, makes up its signature Since this version of main ignores any inputs, we leave off names of the input variables, and only give their types What about the stuff in braces? It’s the body of function main, its definition

What’s cout << “hello, world!” << endl; ? Uses the standard output iostream, named cout For standard input, use cin For standard error, use cerr << is an operator for inserting into the stream “hello, world!” is a C-style string A 14-postion character array terminated by ‘\0’ endl is an iostream manipulator Ends the line, by inserting end-of-line character(s) Also flushes the stream

The main function should return an integer What about return 0; ? The main function should return an integer By convention it should return 0 for success And a non-zero value to indicate failure The program should not exit any other way Letting an exception propagate uncaught Dividing by zero Dereferencing a null pointer Accessing memory not owned by the program Indexing an array “out of range” can do this Dereferencing a “stray” pointer can do this

A Slightly Bigger C++ Program #include <iostream> using namespace std; int main (int argc, char * argv[]) { for (int i = 0; i < argc; ++i) cout << argv[i] << endl; } return 0;

A way to affect the program’s behavior int argc, char * argv[] A way to affect the program’s behavior Carry parameters with which program was called Passed as parameters to main from crt0 Passed by value (we’ll discuss what that means) argc An integer with the number of parameters (>=1) argv An array of pointers to C-style character strings Its array-length is the value stored in argc The name of the program is kept in argv[0]

for (int i = 0; i < argc; ++i) Standard C++ for loop syntax Initialization statement done once at start of loop Test expression done before running each time Expression to increment after running each time int i = 0 Declares integer i (scope is the loop itself) Initializes i to hold value 0 (not an assignment!) Exercise: what happens if you just say int i and leave off the = 0 part? (download program, upload it to grid, change file, update the Makefile) i < argc Tests whether or not we’re still inside the array! Reading/writing memory we don’t own can crash the program (if we’re really lucky!) Exercise: what happens if you say i <= argc ? ++i increments the array position (why prefix?) Exercise: what happens if you leave this statement off?

{cout << argv[i] << endl;} Body of the for loop I strongly prefer to use braces with for, if, while, etc., even w/ single-statement body Avoids maintenance errors when adding/modifying code Ensures semantics & indentation say same thing argv[i] An example of array indexing Specifies ith position from start of argv Exercise: what happens if you index by i+1?