CIS 3142 — Chapter 1

CISC 3142
Programming Paradigms in C++
Chapter 1 — The Basics

Reading from the Text

You can ignore the import discussion in §1.2.1

1.1 Introduction

imperative programming
procedural programming
C supports these as well

1.2 Programs

Compilation, linking, execution
source, object, executable files
language features, standard library
static typing

1.2.1 Hello World

main function

Sample C++ Program #1

#include <iostream>

int main() 
	std::cout << "Hello world" << std::endl;
}

#include <iostream>

using namespace std;

int main() 
	cout << "Hello world" << endl;
}

1.3 Functions

function declaration vs function definition

…

void displayHello();	// declaration — function header only

int main() {
	displayHello();
}

void displayHello() {	// definition — has body
	cout << "Hello world1" <<;
}

forward reference
- This terminology arises in several contexts in the language

1.4 Types, Variables, and Arithmetic

type, object, value, variable
- Java's uses the term object in a more restricted manner
fundamental types: map directly to hardware and has fixed size: int, doublea, bool, char, etc
- Use of ' as literal separator ... 123'45'6789.

Declarations

A declaration is a statement that introduces a name into the program. It specifies a type for the named entity:

A type defines a set of possible values and a set of operations (for an object).
An object is some memory that holds a value of some type.
A value is a set of bits interpreted according to a type.
A variable is a named object.

bool as integer type

opens the possibility of bugs like

cin >> x >> y;
while (x = y) {		// Note this is an assignment, not an equality test
	// do something with x and y
	cin >> x >> y;
}

the result of the assignment (the int-value of y assigned to x) is converted to boolean: 0 → false; everything else → true
loop will be entered until 0 is read into y, regardless of whether x and y are equal
this 'mistake' is not possible in Java

char - usually 8 bit

w_char and other character types fill in the Unicode gap

const / constexpr

variables declared with the const modifier can only be assigned to once

constexpr must be a compile-time value

1.4.1 Arithmetic

Usual suspects: arithmetici (simple and compound), comparison, logical, iand bitwise.

1.4.2 Initialization

`auto`

inferring type from initializer using auto
- avoid having to write long/complicated type names
- avoid having to figure out the exact type when the semantics give you the basic idea
```
auto i = 17;	// int — Doh
		
```
```
Rational r;		
…
auto n = r.getNum();	// don't have to go look up the return type of 'getNum'
		
```
```
std::vector<SomeLongClassName> vect;

// an iterator for the above class has type std::vector<SomeLongClassName>::iterator
for (auto iter = vect.begin(); iter != vect.end(); iter++)
	…
		
```
- auto was already a keyword in C
- Before C++ 1, auto was an anachronistic way of declaring a local variable (which automatically goes in and out of scope lifetime upon entry/exit of the function)

1.5 Scope and Lifetime

local scope: declared within a function. Scope is from point of declaration to end of block ({} in which declared.
class scope: defined in class, outside of any function. Scope is entire block ({}) of declaration
namespace scope: defined in a namespace outside of any class or function. Scope is from point of declaration to end of namespace.
global scope: declared anywhere else

1.6 Constants

const: value may not be changed. May be a runtime value (used mainly in parameter specification for references that should not be modified, and values that should not be modified)
constexpr: value must calculable by compiler. (used for 'real' constants, and performance).

1.7 Pointers, Arrays, and References

Pointers

pointer: memory address
typed; must declare what type value the pointer is referencing
- too chaotic otherwise, referencing an integer value and then using it as a floating point is a nasty bug to catch
- with typed pointers, the compiler can perform proper conversions or flag an error

requires explicit dereferencing

#include <iostream>

using namespace std;
                   
int main() {      
    int i = 17;             
    int *ip = &i;       // ip is a pointer to integer; & is 'address-of' operator 
    cout << "ip: " << " " << ip << " *ip: " << *ip << endl;        
    (*ip)++;                // increments what the pointer points at
    cout << "ip: " << " " << ip << " *ip: " << *ip << endl;
    ip++;               // increment pointer
    cout << "ip: " << " " << ip << " *ip: " << *ip << endl;

    return 0;                                             
}

the above produces the output:

ip:  0x16d392d98 *ip: 17
ip:  0x16d392d98 *ip: 18
ip:  0x16d392d9c *ip: 0

Note: the effect of incrementing a pointer — or performing other arithmetic operations on a pointer — depends on the type of data the pointer is referencing; we will discuss this further when we present pointers in more detail.

Employee e;	// e is of type Employee (class type)		
Employee *ep = &e;
…
cout << ep;		// 	"
cout << *ep;		// 	"
…
//ep.getEmpId();			// illegal … ep is not an class object, it's a pointer
(*ep).getEmpId();		// dereference ep to get the class object, then use member selection (.) operator
//*ep.getEmpId();		// also illegal … postfix operators have precedence, so this is *(ep.getEmpId())
ep->getEmpId();		// intuitive, convenient notation for member selection through a pointer

an example of what is (erroneously) termed 'call-by-reference':
```
void swap(int *ip1, int *ip2) {
	int templ = *ip1;
	*ip1 = *ip2;
	*ip2 = temp;
}
…
swap(&x, &y);	// x and y are declared as int
		
```
- This is still call-by-value — the values that are being passed are the addresses of the integer objects to be swapped
  - and it is those values that are copied when the function is called, and then destroyed when the function exits
  - it is the indirection provided by passing pointers to the objects to be swapped — rather than the objects themselves, that provides us with the desired semantics
  - note the explicit presence and use of the operators and machinery (*, &) associated with pointers and indirection; this will NOT be the case with true call-by-reference (using references)
  - the above is sometimes referred to as call-by-pointer … a somewhat misleading term as it is still nothing more than call-by-value

Here is a more comprehensive write-up on pointers, arrays, references, and several related topics

`void *`

pointer to nothing/everything
used to override pointer typing system; primarily for systems programming (accessing arbitrary addresses)

`nullptr`

No address will be allocated at 0, so 0 is a good choice for a null pointer
before nullptr, NULL was defined as a macro for 0
```
#define NULL 0
		
```
nullptr is an abstraction of 0 / NULL
part of the language (known to the compiler)
single nullptr, rather than one for each pointer type

Arrays

require constant size

int a[10];	// note bracket location

const int MAX_SIZE = 100;
Employee a[MAX_SIZE];

Usual subscripting semantics

int a[10] = {…}
for (int i = 0; i < 9; i++) {
	cout << a[i];
}

Can use a pointer to move through an array

int a[10] = {…}
int *ip = &a[0];
for (int i = 0; i < 9; i++) {
	cout << *ip;
	ip++;
}

no bounds checking; no length field

References

reference: abstraction of pointer
pointers with transparent dereferencing; i.e., no explicit dereferencing necessary
alias of another object
no 'reseating'; i.e., once a reference is assigned a value, it's permanent

no way of working with the reference itself

int i = 17;
int &ir = i;	// MUST be initialized in this context; rarely used in this manner
…
ir++;			// increments i

// This is the primary use for reference
void f(int &x, int &y);	// true call-by-reference
…
f(a, b);

and here is an example of true 'call-by-reference':
```
void swap(int &ir1, int &ir2) {
	int temp = ir1;
	ir1 = ir2;
	ir2 = temp;
}
…
swap(x, y);	// x and y are declared as int
		
```
- The compiler passes the addresses of the arguments (as references) to the parameters
- The reference parameters act as aliases to the arguments
- Note the absence of the pointer/indirection operators/machinery
  - That's the whole point of the reference type — the compiler provides the referencing/dereferencing machinery behind the scenes

CISC 3142 Programming Paradigms in C++ Chapter 1 — The Basics