C++ Advanced Features

1
C++ Advanced
Features
Trenton Computer Festival
March 17, 2018
Michael P. Redlich
@mpredli
about.me/mpredli/

Who’s Mike?
• BS in CS from
• “Petrochemical Research Organization”
• Java Queue News Editor, InfoQ
• Ai-Logix, Inc. (now AudioCodes)
• Amateur Computer Group of New Jersey
2

Objectives
• Overloaded Operators
• Templates
• Exception Handling
• Namespaces
• Introduction to the Standard Template
Library (STL)
3

What are Overloaded
Operators?
• Deﬁne basic operations for objects of user-
deﬁned types
• as if they were built-in types
• Often referred to as “syntactic sugar”
5

6
// String.h - a simple string class
class String {
private:
char *string;
public:
String(char const *str) {
string = new char[strlen(str) + 1];
strcpy(string,str);
}
~String(void) {
delete[] string;
}
char *getString(void) const {
return string;
}
};

7
// main application
#include “String.h”
// create two different objects of type String
String string1 = “Hello, C++ Users Group!”;
String string2 = “Hello, Java Users Group!”;
// a conditional *without* an overloaded equality operator
if(strcmp(string1.getString(),string2.getString()) == 0)
// do this
else
// do that
// a conditional *with* an overloaded equality operator
if(string1 == string2)
// do this
else
// do that

Overloaded Operators
(1)
• An overloaded operator has the form:
• T [class::]operatorω(paramList)
8

(2)
•string1 == string2
• interpreted as
string1.operator==(string2);
• string1 is the object in control
• string2 is the argument passed into the
operator
9

10
// Equality Operator
bool string::operator==(string const &s) {
return(strcmp(
getString(),s.getString()) == 0);
}

(3)
• Attractive, but can be dangerous!!
• deep vs. shallow copy
• assignment operator side effects
• The compiler automatically generates an
assignment operator if one is not explicitly
deﬁned
• memberwise assignments
11

(4)
12
“Hello, C++ Users Group!”
“Hello, Java Users Group!”
string1.string
string2.string

13
// compiler-generated Assignment Operator
string &string::operator=(string const &s) {
string = s.string;
return *this;
}
// main application
string1 = string2;

(5)
14
“Hello, C++ Users Group!”
string1.string
string2.string

15
// user-defined Assignment Operator
string &string::operator=(string const &s) {
delete[] string;
string = new char[strlen(s) + 1];
strcpy(string,s);
return *this;
}
// application
string1 = string2;

(6)
16
string1.string
string2.string

(7)
17
Operators Than Can Be Overloaded
+ - * / % ^ & | ~ !
= < > += -+ *= /= %= ^= &=
|= << >> >>= <<= != <= >= &&
|| ++ -- ‘ ->* -> () []
ne
w
de
le
te

(8)
18
Operators That Cannot Be Overloaded
. .* :: ?:

(9)
• Limitations:
• the meaning of an operator cannot be changed
• the number of operands for an operator cannot
be changed
• operator precedence and associativity cannot be
changed
• no personal operators!!
19

What are Templates?
• Used for generic programming
• Two kinds:
• class templates
• member function templates
21

Templates (1)
• Prototypes:
• template <class T> returnType
functionName(paramList) {}
• template <class T> class
className {}
22

23
// swap member functions to handle different data types
void swap(int &first,int &second) {
int temp = second;
second = first;
first = temp;
}
void swap(float &first,float &second) {
float temp = second;
second = first;
first = temp;
}
void swap(char *&first,char *&second) {
char *temp = second;
second = first;
first = temp;
}

24
/*
* function template to swap two elements
* of any data type
*/
template <class T>
void swap(T &first,T &second) {
T temp = second;
second = first;
first = temp;
}

Templates (2)
• A template specialization is the speciﬁc use
of a template member function or class
• swap<int>(1,2);
• swap<float>(1.7,3.5);
• swap<char>(‘a’,’b’);
• swap<char *>(“Mets”,”Jets”);
25

What is Exception
Handling?
• A more robust method for handling errors
than fastidiously checking for error codes
• error code checking is tedious and can obscure
program logic
27

Exception Handling (1)
• Throw Expression:
• raises the exception
• Try Block:
• contains a throw expression or a member
function that throws an exception
28

• Catch Clause(s):
• handles the exception
• deﬁned immediately after the try block
• multiple catch clauses allowed
• no implicit data type conversions
• catch(...) catches any exception type
29

C++ Exception Model
• Destructors invoked for all live objects as
the stack “unwinds”
• Exception Speciﬁcation
• specify what type of exception(s) a member
function will throw
• Termination vs. Resumption semantics
30

31
// exception handling example
#include <string>
#include <stdexcept>
void fred(void) {
FILE *file = fopen(“filename.txt”,”rt”);
try {
if(file == NULL) { // file could not be opened
throw 1;
}
int g = george(-1);
}
catch(int e) {
cout << “ERROR: Could not open file...” << endl;
}
catch(string const message) {
cout << message << endl;
}
// other statements...
}
// continued on next slide...

32
// continued from previous slide...
int george(int n) {
if(n < 0) {
string message = “ERROR: Value less than zero...”;
throw message;
}
return n;
}

C++ Exception Class
Hierarchy (1)
• exception
• logic_error (client program errors)
• runtime_error (external errors)
• bad_alloc (memory allocation errors)
33

C++ Exception Class
Hierarchy (2)
• exception
• bad_cast (dynamic casting errors)
• bad_exception (unexpected())
• bad_typeid (RTTI errors)
34

35
// exception handling example (revised)
#include <string>
#include <stdexcept>
void fred(void) {
FILE *file = fopen(“filename.txt”,”rt”);
try {
if(file == NULL) { // file could not be opened
throw runtime_error(“ERROR: Could not open file...”);
}
int g = george(-1);
}
catch(runtime_error &re) {
cout << re.what() << endl;
}
catch(string const message) {
cout << message << endl;
}
}

• Do not throw exceptions:
• to indicate special return values
• in copy constructors and assignment operators
• stroustrup.com/3rd_safe.pdf
36

What are Namespaces?
• Used to prevent global naming conﬂicts
• All C++ standard library components are
contained within a single namespace called
std
38

39
// an example of using header files from different sources
// baseball.h
...
int strike = 0;
...
// bowling.h
...
bool strike = false;
...
// main application
#include baseball.h
#include bowling.h // ERROR: strike already declared

40
// an example of using header files from different sources
// baseball.h
namespace baseball {
...
int strike = 0;
...
}
// bowling.h
namespace bowling {
...
bool strike = false;
...
}
// main application
#include baseball.h
#include bowling.h // OK!

Namespaces (1)
• Fully-qualiﬁed member names:
• namespace name
• scope resolution operator (::)
• member name
• baseball::strike
• bowling::strike
41

Aliases
• Provides shorthand for the fully-qualiﬁed
namespace name
• Has the form:
• namespace m = N;
• namespace bb = baseball;
• namespace bw = bowling;
42

Using Directive
• Provides access to all members of a
namespace without having to write the
fully-qualiﬁed namespace member names
• Has the form:
• using namespace N;
• using namespace baseball;
• using namespace bowling;
43

Using Declaration
• Provides access to individual members of a
namespace without having to write the
fully-qualiﬁed namespace member names
• Has the form:
• using N::m;
• using baseball::strike;
• using bowling::strike;
44

Standard Template
Library (STL)
45

What is the STL?
• A subset of Standard C++
• First developed by HP Labs in 1994
• Three main parts:
• containers
• iterators
• algorithms
46

What are Containers?
• A data structure that contains a sequence
of elements
• Sequential containers:
• organize elements linearly
• Sorted associative containers:
• organize elements based on a key
47

Containers (1)
• Primarily chosen by how well it can
perform certain operations, such as:
• add elements to the container
• remove elements from the container
• rearrange elements within the container
• inspect elements within the container
48

Containers (2)
49
vector deque list set/map
insert O(n) O(n) O(1) O(nlogn)
prepend O(n) O(1) O(1) O(nlogn)
ﬁnd O(n) O(n) O(n) O(nlogn)
X[i] O(1) O(1) O(n) O(n)
pointers 0 1 2 3

What are Iterators?
• A generalization of a C/C++ pointer
• Used to access elements within an ordered
sequence
• Considered the “glue” that tie together
containers and algorithms
50

Iterators
• Five types:
• input
• output
• forward
• bi-directional
• random access
51

52
#include <vector>
typedef vector<int>::iterator iterator
vector<int> v(10);
for(int i = 0;i < 9;++i) {
v.push_back(i);
}
iterator current = v.begin();
iterator last = v.end();
while(current != last) {
cout << *current << “n”;
++current;
}
0 1 2 3 4 5 6 7 8
current last

What are Algorithms?
• Perform various operations on containers
such as:
• searching
• sorting
• transforming
53

Algorithms
• Non-Mutating
• binary_search
• count
• equal
• find
• Mutating
• copy
• generate
• remove
• reverse
• sort
54

Popular C++
Compilers
55
• Embarcadero C++ Builder XE7
• embarcadero.com/products/cbuilder
• MicrosoftVisual C++
• microsoft.com
• Intel System Studio
• software.intel.com/en-us/c-
compilers

Popular C++
Compilers
56
• Open Watcom 1.9 (June 2010)
• openwatcom.org

Local C++ User
Groups
• ACGNJ C++ Users Group
• facilitated by Bruce Arnold
• acgnj.barnold.us
57

Further Reading (1)
58
• C & C++ Code Capsules
• Chuck Allison
• freshsources.com
• The C++ Programming Language
• Bjarne Stroustrup
• stroustrup.com/4th.html

Further Reading (2)
59
• The Annotated C++ Reference Manual
• Margaret Ellis and Bjarne Stroustrup
• stroustrup.com/arm.html
• 1997 C++ Public Review Document
• C++ ISO JTC1/SC22/WG21 Committee
• open-std.org/jtc1/sc22/open/n2356

Upcoming Events
• ACGNJ Java Users Group
• Dr. Venkat Subramaniam
• Monday, March 19, 2018
• DorothyYoung Center for the Arts, Room 106
• Drew University
• 7:30-9:00pm
• “Twelve Ways to Make Code Suck Less”
60

61
Thanks!
mike@redlich.net
@mpredli
redlich.net
slideshare.net/mpredli01
github.com/mpredli01

Upcoming Events
• March 17-18, 2017
•tcf-nj.org
• April 18-19, 2017
•phillyemergingtech.com
62

C++ Advanced Features

More Related Content

What's hot (20)

Similar to C++ Advanced Features (20)

More from Michael Redlich (20)

Recently uploaded (20)

C++ Advanced Features