This document discusses the structure of C++ programs and the development environment. It covers: - C++ programs are made up of source code files (.cpp) containing definitions and header files (.h) containing declarations. - The main() function is where execution begins. It can take arguments like the number of command line parameters and their values. - Common elements of C++ programs include using namespaces, including header files, and defining functions like main(). - The development process involves writing code, compiling, linking, and running the executable. Integrated development environments and command line tools can be used. - C++ classes and templates are also discussed at a high level.

1. CSE 332: C++ program structure and development environment
C++ Program Structure (and tools)
Today we’ll talk generally about C++
development (plus a few platform specifics)
• We’ll develop, submit, and grade code in Windows
• It’s also helpful to become familiar with Linux
– E.g., on shell.cec.wustl.edu
• For example, running code through two different
compilers can catch a lot more “easy to make” errors

2. CSE 332: C++ program structure and development environment
Writing a C++ Program
C++ source files
(ASCII text) .cpp
Programmer
(you)
emacs
editor
C++ header files
(ASCII text) .h
1 source file
=
1 compilation unit
Makefile
(ASCII text)
Also: .C .cxx .cc
Also: .H .hxx .hpp
readme
(ASCII text)
Eclipse
Visual Studio

3. CSE 332: C++ program structure and development environment
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 { typedef unsigned int UINT32;
public:
Simple (int i); int usage (char * program_name);
void print_i ();
private: struct Point2D {
int i_; double x_;
}; double y_;
};
• Definitions: static variable initialization, function implementation
– The part that turns into an executable program
– Usually kept in “source” (.cpp) files
void Simple::print_i ()
{
cout << “i_ is ” << i_ << endl;
}
• Directives: tell compiler (or precompiler) to do something
– More on this later

4. CSE 332: C++ program structure and development environment
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;
}

5. CSE 332: C++ program structure and development environment
What is #include <iostream> ?
• #include tells the precompiler to include a file
• Usually, we include header files
– Contain declarations of structs, classes, functions
• Sometimes we include template definitions
– Varies from compiler to compiler
– Advanced topic we’ll cover later in the semester
• <iostream> is the C++ label for a standard
header file for input and output streams

6. CSE 332: C++ program structure and development environment
What is using namespace std; ?
• The using directive tells the compiler to include
code from libraries that have separate namespaces
– Similar idea to “packages” in other languages
• C++ provides a namespace for its standard library
– Called the “standard namespace” (written as std)
– cout, cin, and cerr standard iostreams, and much more
• Namespaces reduce collisions between symbols
– Rely on the :: scoping operator to match symbols to
them
– If another library with namespace mylib defined cout we
could say std::cout vs. mylib::cout
• Can also apply using more selectively:
– E.g., just using std::cout

7. CSE 332: C++ program structure and development environment
What is int main (int, char*[]) { ... } ?
• Defines the main function of any C++ program
• Who calls main?
– The runtime environment, specifically a function often called
something like crt0 or crtexe
• 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

8. CSE 332: C++ program structure and development environment
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
– A member operator of the ostream class
– Returns a reference to stream on which its called
– Can be applied repeatedly to references left-to-right
• “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

9. CSE 332: C++ program structure and development environment
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

10. CSE 332: C++ program structure and development environment
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;
}

11. CSE 332: C++ program structure and development environment
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]

12. CSE 332: C++ program structure and development environment
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!)
• 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!)
• ++i
– increments the array position (why prefix?)

13. CSE 332: C++ program structure and development environment
{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

14. CSE 332: C++ program structure and development environment
Lifecycle of a C++ Program
C++
source code
Makefile
Programmer
(you)
object code
(binary, one per compilation unit) .o
make
“make” utility
xterm
console/terminal/window
Runtime/utility
libraries
(binary) .lib .a .dll .so
gcc, etc.
compiler
link
linker
E-mail
executable
program
Eclipse
debugger
precompiler
compiler
link
turnin/checkin
An “IDE”
WebCAT
Visual Studio
window
compile

15. CSE 332: C++ program structure and development environment
Development Environment Studio
• We’ll follow a similar format most days in the course
– Around 30 minutes of lecture and discussion
– Then about 60 minutes of studio time
– Except for reviews before midterm/final, and midterm itself
• In the studios, please work in groups of 2 or 3
– Exercises are posted on the course web page
– Record your answers to the exercises, and e-mail your
answers to the course account when you’re done
– We’ll migrate throughout the studio to answer questions
• Use studio time to develop skills and understanding
– A good chance to explore ideas you can use for the labs
– Exams will test understanding of the studio material
– You’re encouraged to try variations beyond the exercises