From Procedural to Objectoriented Programming Procedural programming Functions

From Procedural to Object-oriented Programming • Procedural programming – Functions have been the main focus so far • Function parameters and return values • Exceptions and how the call stack behaves – We have viewed data and functions as being separate abstractions, for the most part • Object-oriented (a. k. a. OO) programming – Allows us to package data and functions together • Makes data more interesting (adds behavior) • Makes functions more focused (restricts data scope) – This module will start to look at OO programing • Classes/structs, member operators/functions/variables • We’ll cover inheritance, polymorphism, substitution later CSE 332: C++ Classes

From C++ Functions to C++ Structs/Classes • C++ functions encapsulate behavior – Data used/modified by a function must be passed in via parameters – Data produced by a function must be passed out via return type • Classes (and structs) encapsulate related data and behavior – Member variables maintain each object’s state – Member functions (methods) and operators have direct access to member variables of the object on which they are called – Class members are private by default, struct members public by default • When to use a struct – Use a struct for things that are mostly about the data – Add constructors and operators to work with STL containers/algorithms • When to use a class – Use a class for things where the behavior is the most important part – Prefer classes when dealing with encapsulation/polymorphism (later) CSE 332: C++ Classes

Using Structs and Operators with STL Containers #include <vector> // standard template library #include <iostream> using namespace std; #include “point 2 d. h” // using user-defined code // main function definition int main (int, char *[]) { vector<Point 2 D> v; // must give a type here v. push_back(Point 2 D(2, 3)); v. push_back(Point 2 D(1, 4)); for (size_t s = 0; s < v. size(); ++s) { cout << v[s] << endl; // needs Point 2 D << } return 0; } CSE 332: C++ Classes

Using Structs and Operators with STL Algorithms // same as before, and add algorithm library #include <vector> #include <algorithm> using namespace std; #include “point 2 d. h” int main (int, char *[]) { vector<Point 2 D> v; v. push_back(Point 2 D(2, 3)); v. push_back(Point 2 D(1, 4)); // reorders the points in the vector // note that you don’t give a type here! sort (v. begin(), v. end()); // needs Point 2 D < return 0; } CSE 332: C++ Classes

Declaring and Defining C++ Structs/Classes // struct declaration (in point 2 d. h) struct Point 2 D { also may need == Point 2 D (int x, int y); bool operator< (const Point 2 D &) const; int x_; promises not to int y_; modify object on }; also may need << (outside struct) which it’s called // method definitions (in point 2 d. cpp) Point 2 D: : Point 2 D (int x, int y) : x_(x), y_(y) {} base class/struct and member initialization list scoping operator bool Point 2 D: : operator< (const Point 2 D & p 2 d) const { return (x_ < p 2 d. x_) || ((x_ == p 2 d. x_) && (y_ < p 2 d. y_)); } CSE 332: C++ Classes

Structure of a Simple C++ Class Declaration class Date { public: // member functions, visible outside the class operators can be member functions as well Date (); // default constructor Date (const Date &); // copy constructor The compiler defines these 4 if you don’t* Date (int d, int m, int y); // another constructor virtual ~Date (); // (virtual) destructor Date & operator= (const Date &); // assignment operator int d () const; int m () const; int y () const; // accessors void d (int); void m (int); void y (int); // mutators string yyyymmdd () const; // generate a formatted string private: // member variables, visible only within functions above int d_; int m_; *Compiler omits default int y_; }; Don’t forget semicolon at the end of the class declaration CSE 332: C++ Classes constructor if any constructor is declared

Constructors class Date { • public: Date (); Date (const Date &); • Date (int d, int m, int y); //. . . private: int d_, m_, y_; }; • // default constructor base class / Date: : Date () : d_(0), m_(0), y_(0) member initialization {} list // copy constructor Date: : Date (const Date &d) : d_(d. d_), m_(d. m_), y_(d. y_) {} // another constructor Date: : Date (int d, int m, int y) : d_(d), m_(m), y_(y) {} constructor body CSE 332: C++ Classes A constructor has the same name as its class Establishes invariants for the class instances (objects) – Properties that always hold – Like, no memory leaks Passed parameters are used in the base class /member initialization list – You must initialize const and reference members there – Members are constructed in the order they were declared • List should follow that order – Set up invariants before the constructor body is run – Help avoid/fix constructor failure • More on this topic later

A Bit More About Default Constructors • Default constructor takes no arguments – Compiler synthesizes one if no constructors are provided • Does default construction of all class members (a. k. a member-wise) – If you write a default constructor • Can initialize default values via base/member list • Must do this for const and reference members • Default construction of built-in types – Default construction does nothing (leaves uninitialized) – It’s an error (as of C++11) to read an uninitialized variable CSE 332: C++ Classes

Access Control • Declaring access control scopes within a class private: visible only within the class protected: also visible within derived classes (more later) public: visible everywhere – Access control in a class is private by default • but, it’s better style to label access control explicitly • A struct is the same as a class, except – Access control for a struct is public by default – Usually used for things that are “mostly data” • E. g. , if initialization and deep copy only, may suggest using a struct – Versus classes, which are expected to have both data and some form of non-trivial behavior • E. g. , if reference counting, etc. probably want to use a class CSE 332: C++ Classes

Issues with Encapsulation in C++ • Sometimes two classes are closely tied – – – For example, a container and its iterators One needs direct access to the other’s internal details But other classes shouldn’t have such direct access Can put their declarations in the same header file Can put their definitions in the same source file • Poses interesting design forces – How should iterator access members of container? – Making container members public violates encapsulation • Any class, not just iterator could modify them – Make protected, derive iterator from container? • Could work: inheritance for implementation • But, may prove awkward if lots of classes/dependences are involved – Could have lots of fine-grain accessors and mutators • Functions to get and set value of each member variable • But may reduce encapsulation, clutter the interface for other classes CSE 332: C++ Classes

Friend Declarations • Offer a limited way to open up class encapsulation • C++ allows a class to declare its “friends” – Give access to specific classes or functions • A “controlled violation of encapsulation” – Keyword friend is used in class declaration • Properties of the friend relation in C++ – Friendship gives complete access • Friend methods/functions behave like class members • public, protected, private scopes are all accessible by friends – Friendship is asymmetric and voluntary • A class gets to say what friends it has (giving permission to them) • But one cannot “force friendship” on a class from outside it – Friendship is not inherited • Specific friend relationships must be declared by each class • “Your parents’ friends are not necessarily your friends” CSE 332: C++ Classes

Friends Example // in Foo. h class Foo { friend ostream &operator<<(ostream &out, const Foo &f); public: Class declares operator<< as a friend Foo(int) {} – Notice operator<< is not a member of class Foo ~Foo() {} – Gives it access to member variable baz Can now print Foo like a built-in type private: Foo foo; int baz; cout << foo << endl; }; ostream &operator<<(ostream &out, const Foo &f); // in Foo. cpp ostream &operator<<(ostream &out, const Foo &f) { out << f. baz; // f. baz is private so need to be friended return out; } CSE 332: C++ Classes

Operators let a Struct/Class Work with Entire STL #include <vector> #include <iostream> #include <algorithm> using namespace std; #include "point 2 d. h” int main (int, char *[]) { vector<Point 2 D> v; v. push_back(Point 2 D(2, 3)); v. push_back(Point 2 D(1, 4)); v. push_back(Point 2 D(8, 7)); v. push_back(Point 2 D(5, 9)); vector<Point 2 D> t(v); // can copy construct a vector do { // next_permutation needs Point 2 D < next_permutation(v. begin(), v. end()); for (size_t s = 0; s < v. size(); ++s) { cout << v[s] << " "; // needs Point 2 D << } cout << endl; } while (v != t); // needs Point 2 D == for vector<T> != return 0; } CSE 332: C++ Classes