Classes and Structs in C++

Based on materials by Bjarne Stroustrup

www.stroustrup.com/Programming
 Overview
•  Classes
–  Implementation and interface
–  Constructors
–  Member functions
•  Enumerations
•  Operator overloading

2
 Classes
•  The idea:
–  A class directly represents a concept in a program
•  If you can think of “it” as a separate entity, it is plausible that
it could be a class or an object of a class
•  Examples: vector, matrix, input stream, string, FFT, valve
controller, robot arm, device driver, picture on screen, dialog
box, graph, window, temperature reading, clock
–  A class is a (user-defined) type that specifies how
objects of its type can be created and used
–  In C++ (as in most modern languages), a class is the
key building block for large programs
•  And very useful for small ones also
–  The concept was originally introduced in Simula67
3
 Members and member access
•  One way of looking at a class;
class X { // this class’ name is X
// data members (they store information)
// function members (they do things, using the information)
};

•  Example
class X {
public:
int m; // data member
int mf(int v) { int old = m; m=v; return old; } // function member
};
X var; // var is a variable of type X
var.m = 7; // access var’s data member m
int x = var.mf(9); // call var’s member function mf()
4
 Classes

•  A class is a user-defined type

class X { // this class’ name is X
public: // public members -- that’s the interface to users
// (accessible by all)
// functions
// types
// data (often best kept private)
private: // private members -- that’s the implementation details
// (accessible by members of this class only)
// functions
// types
// data
};
5
 Struct and class
•  Class members are private by default:
class X {
int mf();
// …
};
•  Means
class X {
private:
int mf();
// …
};
•  So
X x; // variable x of type X
int y = x.mf(); // error: mf is private (i.e., inaccessible)

6
 Struct and class
•  A struct is a class where members are public by default:
struct X {
int m;
// …
};

•  Means
class X {
public:
int m;
// …
};

•  structs are primarily used for data structures where the

members can take any value
7
 Date:
Structs my_birthday: y
m

// simplest Date (just data) d

struct Date {
int y,m,d; // year, month, day
};

Date my_birthday; // a Date variable (object)

my_birthday.y = 12;
my_birthday.m = 30;
my_birthday.d = 1950; // oops! (no day 1950 in month 30)
// later in the program, we’ll have a problem

8
 Date:
Structs my_birthday: y
m
// simple Date (with a few helper functions for convenience) d
struct Date {
int y,m,d; // year, month, day
};

Date my_birthday; // a Date variable (object)

// helper functions:
void init_day(Date& dd, int y, int m, int d); // check for valid date and initialize

void add_day(Date&, int n); // increase the Date by n days

// …

init_day(my_birthday, 12, 30, 1950); // run time error: no day 1950 in month 30
9
 Date:
Structs my_birthday: y 1950
m 12
// simple Date d
30
// guarantee initialization with constructor
// provide some notational convenience
struct Date {
int y,m,d; // year, month, day
Date(int y, int m, int d); // constructor: check for valid date and initialize
void add_day(int n); // increase the Date by n days
};
// …
Date my_birthday; // error: my_birthday not initialized
Date my_birthday(12, 30, 1950); // oops! Runtime error
Date my_day(1950, 12, 30); // ok
my_day.add_day(2); // January 1, 1951
my_day.m = 14; // ouch! (now my_day is a bad date)
10
 Date:
Classes my_birthday: y 1950
m 12
// simple Date (control access) d 30
class Date {
int y,m,d; // year, month, day
public:
Date(int y, int m, int d); // constructor: check for valid date and initialize
// access functions:
void add_day(int n); // increase the Date by n days
int month() { return m; }
int day() { return d; }
int year() { return y; }
};
// …
Date my_birthday(1950, 12, 30); // ok
cout << my_birthday.month() << endl; // we can read
my_birthday.m = 14; // error: Date::m is private
11
 Classes

•  The notion of a “valid Date” is an important special case of the

idea of a valid value
•  We try to design our types so that values are guaranteed to be valid
–  Or we have to check for validity all the time
•  A rule for what constitutes a valid value is called an “invariant”
–  The invariant for Date (“Date must represent a date in the past, present, or
future”) is unusually hard to state precisely
•  Remember February 28, leap years, etc.
•  If we can’t think of a good invariant, we are probably dealing with
plain data
–  If so, use a struct
–  Try hard to think of good invariants for your classes
•  that saves you from poor buggy code

12
 Date:
Classes my_birthday: y 1950
m 12
// simple Date (some people prefer implementation details last) d 30
class Date {
public:
Date(int y, int m, int d); // constructor: check for valid date and initialize
void add_day(int n); // increase the Date by n days
int month();
// …
private:
int y,m,d; // year, month, day
};
Date::Date(int yy, int mm, int dd) // definition; note :: “member of”
:y(yy), m(mm), d(dd) { /* … */ }; // note: member initializers
void Date::add_day(int n) { /* … */ }; // definition

13
 Date:
Classes my_birthday: y 1950
m 12
// simple Date (some people prefer implementation details last) d 30
class Date {
public:
Date(int y, int m, int d); // constructor: check for valid date and initialize
void add_day(int n); // increase the Date by n days
int month();
// …
private:
int y,m,d; // year, month, day
};

int month() { return m; } // error: forgot Date::

// this month() will be seen as a global function
// not the member function, can’t access members
int Date::season() { /* … */ } // error: no member called season
14
 Classes
// simple Date (what can we do in case of an invalid date?)
class Date {
public:
class Invalid { }; // to be used as exception
Date(int y, int m, int d); // check for valid date and initialize
// …
private:
int y,m,d; // year, month, day
bool check(int y, int m, int d); // is (y,m,d) a valid date?
};
Date:: Date(int yy, int mm, int dd)
: y(yy), m(mm), d(dd) // initialize data members
{
if (!check(y,m,d)) throw Invalid(); // check for validity
}
15
 Classes

•  Why bother with the public/private distinction?

•  Why not make everything public?
–  To provide a clean interface
•  Data and messy functions can be made private
–  To maintain an invariant
•  Only a fixed set of functions can access the data
–  To ease debugging
•  Only a fixed set of functions can access the data
•  (known as the “round up the usual suspects” technique)
–  To allow a change of representation
•  You need only to change a fixed set of functions
•  You don’t really know who is using a public member
16
 Enumerations

•  An enum (enumeration) is a very simple user-defined

type, specifying its set of values (its enumerators)
•  For example:
enum Month {
jan=1, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec
};

Month m = feb;
m = 7; // error: can’t assign int to Month
int n = m; // ok: we can get the numeric value of a Month
Month mm = Month(7); // convert int to Month (unchecked)

17
 Enumerations

•  Simple list of constants:

enum { red, green }; // the enum { } doesn’t define a scope
int a = red; // red is available here
enum { red, blue, purple }; // error: red defined twice

•  Type with list of constants

enum Color { red, green, blue, /* … */ };
enum Month { jan, feb, mar, /* … */ };

Month m1 = jan;
Month m2 = red; // error red isn’t a Month
Month m3 = 7; // error 7 isn’t a Month
int i = m1; // ok: an enumerator is converted to its value, i==0
18
 Enumerations – Values

•  By default
// the first enumerator has the value 0,
// the next enumerator has the value “one plus the value of the
// enumerator before it”
enum { horse, pig, chicken }; // horse==0, pig==1, chicken==2

•  You can control numbering

enum { jan=1, feb, march /* … */ }; // feb==2, march==3
enum stream_state { good=1, fail=2, bad=4, eof=8 };
int flags = fail+eof; // flags==10
stream_state s = flags; // error: can’t assign an int to a stream_state
stream_state s2 = stream_state(flags); // explicit conversion (be careful!)

19
 Classes Date:
1950
// simple Date (use Month type) my_birthday: y
class Date { m 12
public:
d 30
enum Month {
jan=1, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec
};
Date(int y, Month m, int d); // check for valid date and initialize
// …
private:
int y; // year
Month m;
int d; // day
};
Date my_birthday(1950, 30, Date::dec); // error: 2nd argument not a Month
Date my_birthday(1950, Date::dec, 30); // ok
20
 Const

class Date {
public:
// …
int day() const { return d; } // const member: can’t modify
void add_day(int n); // non-const member: can modify
// …
};

Date d(2000, Date::jan, 20);

const Date cd(2001, Date::feb, 21);

cout << d.day() << " – " << cd.day() << endl; // ok
d.add_day(1); // ok
cd.add_day(1); // error: cd is a const
21
 Const
//
Date d(2004, Date::jan, 7); // a variable
const Date d2(2004, Date::feb, 28); // a constant
d2 = d; // error: d2 is const
d2.add(1); // error d2 is const
d = d2; // fine
d.add(1); // fine

d2.f(); // should work if and only if f() doesn’t modify d2

// how do we achieve that? (say that’s what we want, of course)

22
 Const member functions
// Distinguish between functions that can modify (mutate) objects
// and those that cannot (“const member functions”)
class Date {
public:
// …
int day() const; // get (a copy of) the day
// …
void add_day(int n); // move the date n days forward
// …
};

const Date dx(2008, Month::nov, 4);

int d = dx.day(); // fine
dx.add_day(4); // error: can’t modify constant (immutable) date

23
 Classes
•  What makes a good interface?
–  Minimal
•  As small as possible
–  Complete
•  And no smaller
–  Type safe
•  Beware of confusing argument orders
–  Const correct

24
 Classes
n Essen%al  opera%ons  
n Default  constructor  (defaults  to:  nothing)  
n No  default  if  any  other  constructor  is  declared  
n Copy  constructor  (defaults  to:  copy  the  member)  
n Copy  assignment  (defaults  to:  copy  the  members)  
n Destructor  (defaults  to:  nothing)  
n For  example  
Date  d;  //  error:  no  default  constructor  
Date  d2  =  d;  //  ok:  copy  ini3alized  (copy  the  elements)  
d  =  d2;  //  ok  copy  assignment  (copy  the  elements)  

25
Interfaces and “helper functions”

•  Keep a class interface (the set of public functions)

minimal
–  Simplifies understanding
–  Simplifies debugging
–  Simplifies maintenance

•  When we keep the class interface simple and

minimal, we need extra “helper functions” outside
the class (non-member functions)
–  E.g. == (equality) , != (inequality)
–  next_weekday(), next_Sunday()

26
 Helper functions
Date next_Sunday(const Date& d)
{
// access d using d.day(), d.month(), and d.year()
// make new Date to return
}
Date next_weekday(const Date& d) { /* … */ }

bool operator==(const Date& a, const Date& b)

{
return a.year()==b.year()
&& a.month()==b.month()
&& a.day()==b.day();
}
bool operator!=(const Date& a, const Date& b) { return !(a==b); }
27
 Operator overloading
•  You can define almost all C++ operators for a
class or enumeration operands
–  that’s often called “operator overloading”
enum Month {
jan=1, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec
};
Month operator++(Month& m) // prefix increment operator
{
m = (m==dec) ? jan : Month(m+1); // “wrap around”
return m;
}
Month m = nov;
++m; // m becomes dec
++m; // m becomes jan
28
 Operator overloading
•  You can define only existing operators
–  E.g., + - * / % [] () ^ ! & < <= > >=
•  You can define operators only with their conventional number
of operands
–  E.g., no unary <= (less than or equal) and no binary ! (not)
•  An overloaded operator must have at least one user-defined
type as operand
–  int operator+(int,int); // error: you can’t overload built-in +
–  Vector operator+(const Vector&, const Vector &); // ok
•  Advice (not language rule):
–  Overload operators only with their conventional meaning
–  + should be addition, * be multiplication, [] be access, () be call, etc.
•  Advice (not language rule):
–  Don’t overload unless you really have to

29