1.4 Abstract Data Types, Interfaces, and Pre- and Postconditions 1.3 Defining C++ Classes 1.4 Abstract Data Types, Interfaces, and Pre- and Postconditions 07 – Software Design

Attendance Quiz #6 Software Design

Tip #7: The Rule of Seven Software Design There is a rule of nature commonly known as the 'rule of seven'. This appears in grouping situations, where control is optimized around the seven mark. It appears in a wide number of situations, from the grouping of leaves on plants, to the number of layers in the OSI network model, to the number of layers of management in the Catholic church, to the number of chunks of information that the short-term memory can comfortably handle. A simple application of the rule of seven in programming is where there might be seven chunks of code in a function, each containing seven statements, thus giving a reasonable function size of around 49 lines. The actual grouping count in many situations is actually rather inexact, and an extension to this rule is 'seven, plus or minus two'. Thus, if the size of a group is steadily increasing, when it gets to ten it can be broken into two independent groups of five, each of which now fits back into the bottom end of the five to nine range. Applying this rule of seven extension to the reasonable function size example gives a function size range of between 25 and 100 lines.

1.3, pgs. 75-97 1.3 Defining C++ Classes Class Definition The public and private Parts Class Implementation Using Class Clock The Class Person Constructors Modifier and Accessor Member Functions Operators Friends Implementing the Person Class An Application That Uses Class Person Classes as Components of Other Classes Array Data Fields Documentation Style for Classes and Functions 1.3, pgs. 75-97

Classes A class is a data type and a pattern for creating objects. Software Design A class is a data type and a pattern for creating objects. #ifndef PERSON_H #define PERSON_H #include <string> using std::string; class Person { private: string name; int age; public: Person(string, int); string getName() const; int getAge() const; string toString() const; }; #endif // PERSON_H #include <iostream> #include <string> #include <sstream> #include "person.h" using namespace std; Person::Person(string name, int age) { this->name = name; this->age = age; } string Person::getName() const { return name; } int Person::getAge() const { return age; } string Person::toString() const ostringstream out; out << name << "(" << age << ")"; return out.str(); A class definition describes the names of the class operations and the internal data contents (the data members). instance variables - each class instance (object) has its own storage, usually private to hide implementation details. Member functions (usually public) operate on any object of the class of which it is a member and have access to all the data members of the class object. A class implementation provides the implementations of the operations (the member functions).

Class Access Specifiers Software Design The private access specifier limits access of class members to the class definition. Private data fields Control access to an object's data. Prevent improper use and processing of an object's data. Allow a change of the private data representation without effecting programs that use the class. A friend function of a class has the same access privileges to private and protected data as the class member functions. A friend function is declared by the class that is granting access, so friend functions are part of the class interface, like methods. Since private members of a class are only accessible from within the class, a friend function must also be declared inside of a class, but may be implemented outside of the class. Even though the prototypes for friend functions appear in the class definition, friends are not member functions.

Friends Software Design #include <iostream> #include <string> using namespace std; class MyClass { private: string name; public: MyClass(const string name) { this->name = name; } ~MyClass() = default; friend std::ostream& operator<< (ostream& os, const MyClass& me) os << "MyClass(" << me.name << ")"; return os; } }; int main(int argc, char* argv[]) MyClass me("Suzy Student"); cout << me << endl; return 0; Each member function has an implicit parameter named this whose value is a pointer to the object with which the member function was called. Defines an independent insertion operator function that is a friend of MyClass. The friend insertion operator function has access to MyClass’ private data members. Returns a reference to the output stream that has been modified.

UML Diagrams UML (Unified Modeling Language) classes: Software Design UML (Unified Modeling Language) classes: class Person { private: string given_name; string family_name; string ID_number; int birth_year; public: int age(); bool can_vote(); bool is_senior(); } Class Person has three string and one int data fields. The Person – string relationship (has-a) is represent by the solid diamonds in the following UML diagram:

Unified Modeling Language Software Design Name Airplane -type:string +Airplane() +setType(type:string):void #getType():string Private Public Protected Is-a Jetplane -engine:JetEngine +Jetplane(type:string,engines:int) +getNumberOfEngines():int JetEngine -number:int +JetEngine(number:int) +getNumber():int Has-a

Draw a UML representation of the classes to the left. class Animal { private: string name; public: Animal() {} void setName(string name) { this->name = name; } string getName() { return name; } }; class License int number; License(int n) : number(n) {} int getNumber() { return number; } class Dog : public Animal License license; Dog(string n, int l) : license(l) { setName(n); } int getLicense() { return license.getNumber(); } int main() Dog* dog = new Dog("Rover", 9999); cout << dog->getName() << " " << dog->getLicense(); delete dog; return 0; }

Draw a UML representation of the classes to the left. class Animal { private: string name; public: Animal() {} void setName(string name) { this->name = name; } string getName() { return name; } }; class License int number; License(int n) : number(n) {} int getNumber() { return number; } class Dog : public Animal License license; Dog(string n, int l) : license(l) { setName(n); } int getLicense() { return license.getNumber(); } int main() Dog* dog = new Dog("Rover", 9999); cout << dog->getName() << " " << dog->getLicense(); delete dog; return 0; } Animal -name:string +Animal() +setName(name:string):void +getName():string Dog -license:License +Dog(name:string,license:int) +getLicense():int License -number:int +License(number:int) +getNumber():int

Class/Function Documentation Software Design Documentation comments precede classes, member functions, and data members in a standard format. Originally was developed for the Java language. DOC++ (http://docpp.sourceforge.net/manual/) and Doxygen Enclose function descriptions within /** and */. Tags begin with the symbol @. Use one @param tag for each function parameter. Do not use a @return tag for void functions. /** Encodes a single digit of a POSTNET "A" bar code. @param digit the single digit to encode. @return a bar code of the digit using "|" as the long bar and "," as the half bar. */ string encode(int digit); The first line of the delimitated comment appears in the function summary part of the HTML page.

DOC++ Example class Intermediate Inheritance: Public Methods Software Design /** Just to make the class graph look more interesting. Here we show multiple inheritance from one docified class and a nondocified one. This is how this documentation has been generated: * / class Intermediate : public CommonBase, public NotDocified { … }; class Intermediate Just to make the class graph look more interesting. Inheritance: Inherited from CommonBase: Public Methods const Derived_Class& getB(constIntermediate& c) const Protected Fields double variable

1.4 Abstract Data Types, Interfaces, and Pre- and Postconditions Abstract Data Types (ADTs) and Interfaces An ADT for a Telephone Directory Class Contracts and ADTs Preconditions and Postconditions 1.4, pgs 98-101

Abstract Data Type (ADT) Software Design An Abstract Data Type uses encapsulation of data and methods to hide implementation details. Allows for reusable code. The user doesn't know about implementation details. The public part of a class definition defines the interface for the ADT class. Does not implement the class. Does specify the operations performed and/or how the data is represented. ADT's often can be implemented in more than one way. Each class that implements an ADT must provide the complete definition (implementation) of all operations declared in the ADT. Examples: vectors, linked lists, stacks, etc.

Pre-conditions and Post-conditions Software Design A contract between a function and the function programmer. A pre-condition is a statement of any assumptions or constraints on the function's data (input parameters) that are expected to apply before the function is performed. If a pre-condition is not met, there is no guarantee that the function will do what is expected. A post-condition is a statement that describes the results of the function execution. If pre-conditions are met and post-conditions are not, then the function is considered faulty. When implementing an ADT, we document the preconditions and postconditions in the documentation comments. Post-conditions for operations are comments with a void return type that reflect changes to the object's state. If an operation returns a value, you describe the postcondition in the @return tag.