CSE332S Object-Oriented Programming in C++ (Lecture 2)

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

Extra credit on Lab 1: compile the cpp program in Linux.

Writing C++

Makefile ASCII text

C++ course files, ASCII text, end it with .cpp

C++ header files, ASCII text, end it with .h

readme, ASCII text (show what program does)

Parts of a C++ Program

Declarations

data types, function signatures, class declarations

This allows the compiler to check for type safety, correct syntax, and other errors
Usually kept in header files (e.g., .h)
Included as needed by other files (to make compiler happy)


// my_class.h
class Simple {
    public:
        Simple (int i);
        void print_i();
    private:
        int i_;
}
 
typedef unsigned int UNIT32;
 
int usage (char * program_name);
 
struct Point2D {
    double x_;
    double y_;
};

Definitions

Static variables initialization, function implementation

The part that turns into an executable program
Usually kept in source files (e.g., .cpp)


// my_class.cpp
#include "my_class.h"
 
Simple::Simple (int i) : i_(i) {}
 
void Simple::print_i() {
    std::cout << i_ << std::endl;
}

Directives

tell complier or preprocessor what to do

A Very Simple C++ Program


#include <iostream> // precompiler directive
 
using namespace std; // compiler directive
 
// definition of main function
 
int main(int, char *[]) {
    cout << "Hello, World!" << endl;
    return 0;
}

What is `#include <iostream>`?

#include tells the precompiler to include a file
Usually, we include header files that:
- Contain declarations of structs, classes, functions
- Sometimes contain template definitions (template not included in this course)
Implementation varies from compiler to compiler (advanced topic covered later)
<iostream> is the C++ standard header file for input/output streams

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)
- Contains cout, cin, 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

What is `int main(int, char *[]) { ... }`?

Defines the main function of any C++ program, it is the entry point of the 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

What is `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 it’s called
- Can be applied repeatedly to references left-to-right
"hello, world!" is a C-style string
- A 14-position character array terminated by '\0'
endl is an iostream manipulator
- Ends the line by inserting end-of-line character(s)
- Also flushes the stream

What about `return 0;`?

The main function must return an integer value
By convention:
- Return 0 to indicate successful execution
- Return non-zero value to indicate failure
The program should exit gracefully through main’s return
Other ways the program can terminate abnormally:
- Uncaught exceptions propagating out of main
- Division by zero
- Dereferencing null pointers
- Accessing memory not owned by the program
  - Array index out of bounds
  - Dereferencing invalid/“stray” pointers

A slightly more complex 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;
}

`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]

What is `for (int i = 0; i < argc; i++) { ... }`?

Standard C++ for loop syntax:

Consists of 3 parts:
1. Initialization statement (executed once at start)
2. Test expression (checked before each iteration)
3. Increment expression (executed after each iteration)

Let’s break down each part:

int i = 0:

Declares integer variable i (scoped to the loop)
Initializes i to 0 (initialization, not assignment)

i < argc:

Tests if we’re within array bounds
Critical for memory safety - accessing outside array can crash program

++i:

Increments array position counter
Uses prefix increment operator

Lifecycle of a C++ Program

Start from the makefile

The makefile is a text file that tells the compiler how to build the program, it activates the ‘make’ utility to build the program
- The make file turnin/checkin to the WebCAT E-mail
- The makefile complies the gcc compiler to compile the cpp file
- The makefile links the object files to create the executable file

The cpp file

The cpp file is a text file that contains the source code of the program
- The cpp file is compiled into an object file by the gcc compiler to combined with the link produced by the makefile with the runtime/util library

Finally, the object file is linked with the runtime/util library to create the executable program and ready to debug with Eclipse or Visual Studio.

Development Environment Studio

Course Format

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:
  - Open studio/lab days
  - Reviews before the midterm and final
  - The day of the midterm itself

Studio Guidelines

Work in groups of 2 or 3
Exercises are posted on the course web page
Record your answers and email them to the course account
Instructors will circulate to answer questions

Purpose of Studios

Develop skills and understanding
Explore ideas you can use for labs
Prepare for exams which test studio material
Encouraged to try variations beyond exercises