C 2a3a2h

11. A bit of C++

P2 — A bit of C++

Roap

> > > >

>

C++ vs C C++ vs Java References vs pointers C++ classes: Orthodox Canonical Form A quick look at STL — The Standard Template Library

© O. Nierstrasz

2

P2 — A bit of C++

Roap

> > > >

>

C++ vs C C++ vs Java References vs pointers C++ classes: Orthodox Canonical Form A quick look at STL — The Standard Template Library

© O. Nierstrasz

3

P2 — A bit of C++

Essential C++ Texts

> > > > > >

Bjarne Stroustrup, The C++ Programming Language (Special Edition), Addison Wesley, 2000. Stanley B. Lippman and Josee LaJoie, C++ Primer, Third Edition, Addison-Wesley, 1998. Scott Meyers, Effective C++, 2d ed., Addison-Wesley, 1998. James O. Coplien, Advanced C++: Programming Styles and Idioms, Addison-Wesley, 1992. David R. Musser, Gilmer J. Derge and Atul Saini, STL Tutorial and Reference Guide, 2d ed., Addison-Wesley, 2000. Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, Design Patterns, Addison Wesley, Reading, MA, 1995.

© O. Nierstrasz

4

P2 — A bit of C++

Object-oriented language genealogy

© O. Nierstrasz

11.5

P2 — A bit of C++

What is C?

>

C is a general purpose, procedural, imperative language developed in 1972 by Dennis Ritchie at Bell Labs for the Unix Operating System. — Low-level access to memory — Language constructs close to machine instructions — Used as a “machine-independent assembler”

© O. Nierstrasz

6

P2 — A bit of C++

My first C Program Include standard io declarations A preprocessor directive

#include <stdio.h>

Write to standard output

int main(void) { printf("hello, world\n"); return 0; } char array

Indicate correct termination © O. Nierstrasz

7

P2 — A bit of C++

What is C++?

A “better C” (http://www.research.att.com/~bs/C++.html) that s: > Systems programming > Object-oriented programming (classes & inheritance) > Programming-in-the-large (namespaces, exceptions) > Generic programming (templates) > Reuse (large class & template libraries)

© O. Nierstrasz

8

P2 — A bit of C++

C++ vs C

Most C programs are also C++ programs. Nevertheless, good C++ programs usually do not resemble C: > avoid macros (use inline) > avoid pointers (use references) > avoid malloc and free (use new and delete) > avoid arrays and char* (use vectors and strings) ... > avoid structs (use classes) C++ encourages a different style of programming: > avoid procedural programming — model your domain with classes and templates

© O. Nierstrasz

9

P2 — A bit of C++

Roap

> > > >

>

C++ vs C C++ vs Java References vs pointers C++ classes: Orthodox Canonical Form A quick look at STL — The Standard Template Library

© O. Nierstrasz

10

P2 — A bit of C++

Hello World in Java

package p2; // My first Java program! public class HelloMain { public static void main(String[] args) { System.out.println("hello world!"); return 0; } }

© O. Nierstrasz

11

P2 — A bit of C++

“Hello World” in C++

Use the standard namespace

A C++ comment

cout is an instance of ostream

Include standard iostream classes

using namespace std; #include // My first C++ program! int main(void) { cout << "hello world!" << endl; return 0; } operator overloading (two different argument types!)

© O. Nierstrasz

12

P2 — A bit of C++

Makefiles / Managed Make in CDT You could compile it all together by hand:

c++ helloWorld.p -o helloWorld

Or you could use a Makefile to manage dependencies:

helloWorld : helloWorld.p c++ [email protected] -o $@ make helloWorld

Or you could use cdt with eclipse to create a standard managed make project

© O. Nierstrasz

13

P2 — A bit of C++

C++ Design Goals

“C with Classes” designed by Bjarne Stroustrup in early 1980s: > Originally a translator to C — Initially difficult to debug and inefficient

>

Mostly upward compatible extension of C — “As close to C as possible, but no closer” — Stronger type-checking — for object-oriented programming

>

Run-time efficiency — Language primitives close to machine instructions — Minimal cost for new features

© O. Nierstrasz

14

P2 — A bit of C++

C++ Features

C with Classes

Classes as structs Inheritance; virtual functions Inline functions

C++ 1.0 (1985)

Strong typing; function prototypes new and delete operators

C++ 2.0

Local classes; protected Multiple inheritance

C++ 3.0

Templates Exception handling

ANSI C++ (1998)

© O. Nierstrasz

Namespaces RTTI (Runtime Type Information)

15

P2 — A bit of C++

Java and C++ — Similarities and Extensions

Similarities: > primitive data types (in Java, platform independent) > syntax: control structures, exceptions ... > classes, visibility declarations (public, private) > multiple constructors, this, new > types, type casting (safe in Java, not in C++) > comments

© O. Nierstrasz

Some Java Extensions: > garbage collection > standard abstract machine > standard classes (came later to C++) > packages (now C++ has namespaces) > final classes > autoboxing > generics instead of templates

16

P2 — A bit of C++

Java Simplifications of C++

> >

> > > > > > > >

>

no pointers — just references no functions — can declare static methods no global variables — use public static variables no destructors — garbage collection and finalize no linking — dynamic class loading no header files — can define interface no operator overloading — only method overloading no member initialization lists — call super constructor no preprocessor — static final constants and automatic inlining no multiple inheritance — implement multiple interfaces no structs, unions, enums — typically not needed

© O. Nierstrasz

17

P2 — A bit of C++

New Keywords In addition the keywords inherited from C, C++ adds: Exceptions

Declarations:

Expressions:

© O. Nierstrasz

catch, throw, try bool, class, enum, explicit, export, friend, inline, mutable, namespace, operator, private, protected, public, template, typename, using, virtual, volatile, wchar_t and, and_eq, bitand, bitor, compl, const_cast, delete, dynamic_cast, false, new, not, not_eq, or, or_eq, reinterpret_cast, static_cast, this, true, typeid, xor, xor_eq

(see http://www.glenmccl.com/glos.htm)

18

P2 — A bit of C++

Roap

> > > >

>

C++ vs C C++ vs Java References vs pointers C++ classes: Orthodox Canonical Form A quick look at STL — The Standard Template Library

© O. Nierstrasz

19

P2 — A bit of C++

Memory Layout The address space consists of (at least): Text:

executable program text (not writable)

Static:

static data

Heap:

dynamically allocated global memory (grows upward)

Stack:

local memory for function calls (grows downward)

© O. Nierstrasz

20

P2 — A bit of C++

Pointers in C++

int i; int *iPtr; // a pointer to an integer iPtr = &i; // iPtr contains the address of I *iPtr = 100; variable i iPtr

© O. Nierstrasz

value … 100 456FD4 …

Address in hex 456FD4 456FD0

21

P2 — A bit of C++

References A reference is an alias for another variable: int i = 10; int &ir = i; ir = ir + 1;

i,ir

10

// reference (alias) // increment i

Once initialized, references cannot be changed. References are especially useful in procedure calls to avoid the overhead of ing arguments by value, without the clutter of explicit pointer dereferencing ( y = *ptr;) void refInc(int &n) { n = n+1; // increment the variable n refers to } © O. Nierstrasz

22

P2 — A bit of C++

References vs Pointers

References should be preferred to pointers except when: > manipulating dynamically allocated objects — new returns an object pointer

>

a variable must range over a set of objects — use a pointer to walk through the set

© O. Nierstrasz

23

P2 — A bit of C++

C++ Classes C++ classes may be instantiated either automatically (on the stack): MyClass oVal;

// constructor called // destroyed when scope ends

or dynamically (in the heap) MyClass *oPtr;

// uninitialized pointer

oPtr = new MyClass;

// constructor called // must be explicitly deleted

© O. Nierstrasz

24

P2 — A bit of C++

Constructors and destructors Include standard iostream and string classes #include #include <string> using namespace std; Use initialization class MyClass { list in constructor private: string name; public: MyClass(string name) : name(name) { // constructor Specify cleanup cout << "create " << name << endl; in destructor } ~MyClass() { cout << "destroy " << name << endl; } };

© O. Nierstrasz

25

P2 — A bit of C++

Automatic and dynamic destruction MyClass& start() { MyClass a("a"); MyClass *b = new MyClass("b"); return *b; }

// // // // //

void finish(MyClass& b) { delete &b; }

// need pointer to b

#include "MyClass.h” using namespace std; int main (int argc, char **argv) { MyClass aClass("d"); finish(start()); return 0; } © O. Nierstrasz

returns a reference automatic dynamic returns a reference (!) to b a goes out of scope

create d create a create b destroy a destroy b destroy d 26

P2 — A bit of C++

Roap

> > > >

>

C++ vs C C++ vs Java References vs pointers C++ classes: Orthodox Canonical Form A quick look at STL — The Standard Template Library

© O. Nierstrasz

27

P2 — A bit of C++

Orthodox Canonical Form Most of your classes should look like this: class myClass { public: myClass(void); myClass(const myClass& copy); ... ~myClass(void); myClass& operator=(const myClass&); ... // other private: ... };

© O. Nierstrasz

// default constructor // copy constructor // other constructors // destructor // assignment public member functions

28

P2 — A bit of C++

Why OCF?

If you don’t define these four member functions, C++ will generate them: >

default constructor — will call default constructor for each data member

>

destructor — will call destructor of each data member

>

copy constructor — will shallow copy each data member — pointers will be copied, not the objects pointed to!

>

assignment — will shallow copy each data member

© O. Nierstrasz

29

P2 — A bit of C++

Example: A String Class

We would like a String class that protects C-style strings: > strings are indistinguishable from char pointers > string updates may cause memory to be corrupted Strings should : > creation and destruction > initialization from char arrays > copying > safe indexing > safe concatenation and updating > output > length, and other common operations ... © O. Nierstrasz

30

P2 — A bit of C++

A Simple String.h Returns a reference to ostream

Operator overloading

A friend function prototype declaration of the String class

class String { friend ostream& operator<<(ostream&, const String&); public: String(void); // default constructor Operator ~String(void); // destructor String(const String& copy); // copy constructor overloading inline String(const char*s); // char* constructor String& operator=(const String&); // assignment

of =

inline int length(void) const { return ::strlen(_s); } char& operator[](const int n) throw(exception); String& operator+=(const String&) throw(exception); // concatenation private: char *_s; // invariant: _s points to a null-terminated heap string void become(const char*) throw(exception); // internal copy function };

© O. Nierstrasz

31

P2 — A bit of C++

Default Constructors Every constructor should establish the class invariant: Allocate memory String::String(void) for the string { _s = new char[1]; _s[0] = '\0';

// allocate a char array // NULL terminate it!

}

The default constructor for a class is called when a new instance is declared without any initialization parameters: String anEmptyString; String stringVector[10];

© O. Nierstrasz

// call String::String() // call it ten times!

32

P2 — A bit of C++

Destructors The String destructor must explicitly free any memory allocated by that object. String::~String (void) { delete [] _s; }

free memory

Every new must be matched somewhere by a delete! > use new and delete for objects > use new[] and delete[] for arrays!

© O. Nierstrasz

33

P2 — A bit of C++

Copy Constructors Our String copy constructor must create a deep copy: String::String(const String& copy) { become(copy._s); // call helper } void String::become(const char* s) throw (exception) { _s = new char[::strlen(s) + 1]; if (_s == 0) throw(logic_error("new failed")); ::stry(_s, s); } From std © O. Nierstrasz

34

P2 — A bit of C++

A few remarks ...

>

We must define a copy constructor, … else copies of Strings will share the same representation! — Modifying one will modify the other! — Destroying one will invalidate the other!

>

We must declare copy as const, … else we won’t be able to construct a copy of a const String! — Only const (immutable) operations are permitted on const values

>

We must declare copy as String&, not String, … else a new copy will be made before it is ed to the constructor! — Functions arguments are always ed by value in C++ — The “value” of a pointer is a pointer!

>

The abstraction boundary is a class, not an object. Within a class, all private are visible (as is copy._s)

© O. Nierstrasz

35

P2 — A bit of C++

Other Constructors Class constructors may have arbitrary arguments, as long as their signatures are unique and unambiguous: String::String(const char* s) { become(s); }

Since the argument is not modified, we can declare it as const. This will allow us to construct String instances from constant char arrays. © O. Nierstrasz

36

P2 — A bit of C++

Assignment Operators Assignment is different from the copy constructor because an instance already exists: String& String::operator=(const String& copy) { if (this != ©) { // take care! delete [] _s; become(copy._s); } return *this; // NB: a reference, not a copy }

> Return String& rather than void so the result can be used in an

expression > Return String& rather than String so the result won’t be copied! > this is a pseudo-variable whose value is a pointer to the current object — so *this is the value of the current object, which is returned by reference © O. Nierstrasz

37

P2 — A bit of C++

Implicit Conversion When an argument of the “wrong” type is ed to a function, the C++ compiler looks for a constructor that will convert it to the “right” type:

str = "hello world"; is implicitly converted to: str = String("hello world"); NB: compare to autoboxing in Java © O. Nierstrasz

38

P2 — A bit of C++

Operator Overloading (indexing) Not only assignment, but other useful operators can be “overloaded” provided their signatures are unique: char& String::operator[] (const int n) throw(exception) { if ((n<0) || (length()<=n)) { throw(logic_error("array index out of bounds")); } return _s[n]; }

NB: a non-const reference is returned, so can be used as an lvalue in an assignment. © O. Nierstrasz

39

P2 — A bit of C++

Overloadable Operators The following operators may be overloaded: +

-

*

/

%

^

&

|

-

!

,

=

<

>

<=

>=

++

--

<<

>>

==

!=

&&

||

+=

-=

/=

%=

^=

&=

|=

*=

<<=

>>=

[]

()

->

->*

new

delete

NB: arity and precedence are fixed by C++

© O. Nierstrasz

40

P2 — A bit of C++

Friends We would like to be able to write: cout << String("TESTING ... ") << endl;

But: — It can’t be a member function of ostream, since we can’t extend the standard library. — It can’t be a member function of String since the target is cout. — But it must have access to String’s private data

So ... we need a binary function << that takes a cout and a String as arguments, and is a friend of String. © O. Nierstrasz

41

P2 — A bit of C++

Friends ... We declare:

And define:

© O. Nierstrasz

class String { friend ostream& operator<<(ostream&, const String&); ... };

ostream& operator<<(ostream& outStream, const String& s) { return outStream << s._s; } 42

P2 — A bit of C++

Roap

> > > >

>

C++ vs C C++ vs Java References vs pointers C++ classes: Orthodox Canonical Form A quick look at STL — The Standard Template Library

© O. Nierstrasz

43

P2 — A bit of C++

Standard Template Library

STL is a general-purpose C++ library of generic algorithms and data structures. 1. Containers store collections of objects — 2.

Iterators traverse containers —

3.

arithmetic, comparison, logical, and -defined ...

Algorithms implement generic procedures —

5.

random access, bidirectional, forward/backward ...

Function Objects encapsulate functions as objects —

4.

vector, list, deque, set, multiset, map, multimap

search, count, copy, random_shuffle, sort, ...

Adaptors provide an alternative interface to a component —

stack, queue, reverse_iterator, ...

© O. Nierstrasz

44

P2 — A bit of C++

An STL Line Reverser #include #include <stack> #include <string>

// STL stacks // Standard strings

void rev(void) { typedef stack<string> IOStack; // instantiate the template IOStack ioStack; // instantiate the template class string buf; while (getline(cin, buf)) { ioStack.push(buf); } while (ioStack.size() != 0) { cout << ioStack.top() << endl; ioStack.pop(); } } © O. Nierstrasz

45

P2 — A bit of C++

What we didn’t have time for ... > > > >

> > > > > > > > >

virtual member functions, pure virtuals public, private and multiple inheritance default arguments, default initializers method overloading const declarations enumerations smart pointers static and dynamic casts Templates, STL template specialization namespaces RTTI ...

© O. Nierstrasz

46

P2 — A bit of C++

What you should know!

          

What new features does C++ add to C? What does Java remove from C++? How should you use C and C++ commenting styles? How does a reference differ from a pointer? When should you use pointers in C++? Where do C++ objects live in memory? What is a member initialization list? Why does C++ need destructors? What is OCF and why is it important? What’s the difference between delete and delete[]? What is operator overloading?

© O. Nierstrasz

47

P2 — A bit of C++

Can you answer these questions?

 Why doesn’t C++ garbage collection?  Why doesn’t Java multiple inheritance?  What trouble can you get into with references?  Why doesn’t C++ just make deep copies by default?  How can you declare a class without a default

constructor?  Why can objects of the same class access each others private ?

© O. Nierstrasz

48

P2 — A bit of C++

License http://creativecommons.org/licenses/by-sa/2.5/

Attribution-ShareAlike 2.5 You are free: • to copy, distribute, display, and perform the work • to make derivative works • to make commercial use of the work

Under the following conditions: Attribution. You must attribute the work in the manner specified by the author or licensor.

Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under a license identical to this one.

• For any reuse or distribution, you must make clear to others the license of this work. • Any of these conditions can be waived if you get permission from the copyright holder. Your fair use and other rights are in no way affected by the above. © O. Nierstrasz

49