Classes and Objects. Class scope: - private members are only accessible by the class methods.

Size: px

Start display at page:

Download "Classes and Objects. Class scope: - private members are only accessible by the class methods."

Gervais Norton
5 years ago
Views:

1 Class Declaration Classes and Objects class class-tag //data members & function members ; Information hiding in C++: Private Used to hide class member data and methods (implementation details). Public Used to expose class member data and methods to the client (interface) Class scope: - private members are only accessible by the class methods. Public scope: - public members can be accessed outside the class Member selection operator: - To gain access to data or methods in a class the client must select the field using an appropriate operator. - member selector operator -. (dot) - class indirection operator - -> (dash, greater-than symbol) 08/25/18 1

2 The declaration for a class to represent date. (DateClass.h) class DateClass public: // Member function declarations void Set(int newmo, int newday, int newyr); void Print() const; bool Equal(DateClass otherdate) const; ; private: // Member data declarations int mo; int day; int yr; const at the end of a function declaration indicates that the function doesn t change the data in the object. By default members are private, must use public: to open up members to a client program. (structs default members to public) Example - piece of a client Program (prog.cpp) #include DateClass.h // variable declarations DateClass Date1; DateClass Date2; Visual Image of the DateClass Class objects: Date1 and Date2 Each has its own copies of all members Technically the functions are not duplicated. 08/25/18 2

3 Defining Class Methods: A method may be declared inside the class declaration and defined outside the class declaration. Must use the scope resolution operator (::) in function member header in method definition. A method may be defined inside the class declaration inline The definition for methods in the class to represent date. (DateClass.cpp) #include DateClass.h #include <iostream.h> void DateClass :: Set (int newmo, int newday, int newyr) mo = newmo; day = newday; yr = newyear; void DateClass :: Print() const cout << mo << "/" << day << "/" << yr; bool DateClass :: Equal(DateClass otherdate) const return (( mo == otherdate.mo ) && (day == otherdate.day) && (yr == otherdate.yr)) Using classes in programs: Separate: class.h file contains the class declaration (interface or specification file) class.cpp file contains the class method definitions (implementation file). Is typically compiled into class.o file for use by a client program. client.cpp file contains the client code that #includes the class.h file and is linked with the class.o to create the executable program that solves the problem. 08/25/18 3

4 Efficiency and Robustness Issue for Classes and Objects Passing and Returning Objects by Reference: - objects should be pass by reference & returned by reference (for efficiency) Object References as const parameter: - parameters that are not changing but marked as reference parameters should be marked with const const Methods: - methods that do not change the data members should be marked const - methods marked const should only call other methods marked const - prevents unintended write operations - encourages compiler optimization Constructors and the Destructor invoked automatically by the compiler (not the programmer) Constructors: Member function uses the class name. No return value - return data type is omitted. Can be overloaded but each must have its own signature If a class has multiple constructors then the appropriate constructor is chosen by the actual parameters (or no parameters) passed when the declaration of the class object is made. Default Constructor - parameter-less, must exist to have any constructors (This is the one used in declaration of arrays of a class). Parameterized Constructors - have parameters - matched by the data type and number of parameters passed in the declaration. Copy Constructors Convert Constructors 08/25/18 4

5 add to the DateClass.h the specification of the public member functions for construction: DateClass(); // declaration of the default constructor DateClass(int, int, int); // declaration of a parameterized constructor add to the DateClass.cpp the implementation of the constructors: DateClass::DateClass() mo = 1; day = 1; yr = 2000; DateClass::DateClass(int initmo, int initday, int inityr) mo = initmo; day = initday; yr = inityr; Copy Constructor: Shallow copy - An operation that copies one class object to another without copying any pointed-to data. assignment - Queue1 = Queue2. Pointer values are copied, but both queues point to same data. As items are added and removed from Queue1, this automatically effects Queue2, causes system errors. int *p; int arr[5] = 2, 4, 6, 8, 10 p = new int[5]; p = arr; // What is actually copied???? 08/25/18 5

6 C++ automatically does shallow copying: passing a parameter by value initializing a variable in a declaration using the assignment operator returning a value from a function performing an assignment using the assignment operator Deep copy - An operation that not only copies a class object data to another but also makes copies of any pointed-to data. Copy Constructor - invoked whenever one class object is initialized by another. Initialization Means: (these default to shallow copying without c.c.) 1. Initialization in a variable declaration QueType Q1 (Q2) ; 2. Passing a copy of an actual to formal parameter using pass-by-value. fun1(q1). void fun1(quetype Q) 3. Returning object using return-by-value from a function return (Q);. Q1 = fun1(..); Prototype of the copy constructor: class SomeClass public: SomeClass(const SomeClass& someobject); // copy constructor ; Body of constructor should dynamically allocate memory and copy items from parameter into dynamic memory of this class object. To disable using the object in pass-by-value or return-by-value include the copy constructor in the private section. 08/25/18 6

7 Convert Constructor converts a different data type into this class data type. must be a single parameter constructor can be used implicitly as an alternative to function overloading and explicit casting can be used explicitly to cast and convert (using keyword explicit) add to the DateClass.h the specification for copy & convert constructors: DateClass(const DateClass& d ); // copy constructor DateClass(const string& s ); // convert constructor or explicit DateClass(const string& s); //explicit version add to the DateClass.cpp the implementation of these constructors: DateClass::DateClass(const DateClass & d) mo = d.mo; day = d.day; yr = d.yr; DateClass::DateClass(const string& s) mo = (s[0]- 0 * 10) + (s[1] 0 ); day = (s[2]- 0 * 10) + (s[3] 0 ); yr = (s[4]- 0 * 10) + (s[5] 0 ); 08/25/18 7

8 Constructor Initializers (ctor initializer): Used to initialize any data members Only way to initialize constant data in a constructor Can leave function body empty class SomeClass public: SomeClass( ); private: int dm1; const int dm2; ; SomeClass::SomeClass( ) : dm1(3), dm2(15) cout << dm1 << dm2 <<endl ; // prints 3 and 15 08/25/18 8

9 Destructor - uses same syntax as constructor but member function name has a tilde (~) in front of it. Implicitly invoked when control reaches the end of the block in which the variable is declared ( lifetime is over ). DateClass d1; constructor is invoked destructor is invoked Only necessary if deallocation is not automatic. Deallocation occurs automatically when the private data is enclosed entirely within the abstraction barrier of the class (static memory allocation). ( DateClass). Non-automatic deallocation occurs when there is a pointer within the class that points to dynamic data outside of abstraction barrier ( Dynamic implementation of a list). When the variable is destroyed the only automatic deallocation is the pointer variable, leaving the dynamic data no longer accessible. add to the DateClass.h the specification for destructor: ~DateClass(); // declaration of the destructor add to the DateClass.cpp the implementation of the destructor: DateClass:: ~DateClass() // Body of member function - deallocates any dynamic memory 08/25/18 9

10 Class Data Members and Methods Static data members - belongs to the class itself, not the instance - a data member declared static is created just once for the entire class - declared inside the class declaration using the keyword static - Must be defined outside all blocks and initialized class SomeClass public: private: static int count; // declaration ; int SomeClass::count = 0; // definition Static methods - can only access static members of the class class SomeClass public: static int ReportCount( ) const; private: static int count; // declaration ; int SomeClass::count = 0; // definition int SomeClass::ReportCount( ) const return count; 08/25/18 10

11 Static local variables inside class methods - method has one underlying variable shared by all objects in the class when the method is invoked class SomeClass public: int F1( ) ; private: int d1; ; int SomeClass::F1( ) static int v = 0; v++; return v; // only init once, shared by all objects int main( ) SomeClass a, b, c; cout << a. F1( ) << b. F1( ) << c.f1( ) << endl; // prints 1, 2, 3 08/25/18 11

12 Pointers to Objects Class indirection operator : -> used for pointers to objects int main( ) DateClass* dptr; dptr->set(1,24,2000); dptr->print( ); The Pointer constant this - this pointer can be used inside a method to access the object that invoked the method. - this is equal to the address of the object instance - this pointer is constant and can be accessed in nonstatic methods void DateClass :: Set (int newmo, int newday, int newyr) //mo = newmo; this -> mo = newmo; //day = newday; this -> day = newday; //yr = newyear; this -> yr = newyear; 08/25/18 12

3.Constructors and Destructors. Develop cpp program to implement constructor and destructor.

3.Constructors and Destructors Develop cpp program to implement constructor and destructor. Constructors A constructor is a special member function whose task is to initialize the objects of its class.