Object Oriented Programming COP3330 / CGS5409

 Class Templates  Bitwise Operators

 With class templates, we can make this class work with a variety of types, without resorting to altering and recompiling code.  The class template will work in a similar manner to the function template.  To make a class into a template, prefix the class definition with the syntax: template

 T in the above line is just a type parameter, and it can have any name. Like a function parameter, it is a placeholder.  When the class is instantiated, we fill in an appropriate type. Use this prefix also on the definitions of member functions, and the name of the class used in context with the scope resolution operator will be: className ::memberName

 Notice that in this SimpleList example, the type of the array is T -- the type parameter - - and this will be filled in when an object is created.  mples/templates/simplelist3/ mples/templates/simplelist3/

 Also notice that in the main program, we must #include the actual definition file -- all the template function definitions, in addition to the class definition!  This is because the compiler creates a different version of the class for each type that is used when building objects. This means that either the entire class should be written in the header file,  OR that the.cpp file should be #included, like this: #include "simplelist3.cpp"

 Unlike function templates, overloading is NOT sufficient for implementing class templates, because classes don't have parameter lists.  Instead, we need the full instantiation syntax when declaring: List x; // etc.  The compiler still does it by building multiple versions of the class, for each instantiated type  This means syntax like List ::function() is necessary on definitions, since List is a different class than List, for example.

 The following is an example of a more complicated class that uses array-based storage (dynamic) to maintain a list of items.  This is a class template, so the type of item stored in the list can vary from object to object:  mples/templates/tlist/ mples/templates/tlist/

  cpp : a simple example of a function template. In this case, it is a swap function, for swapping the contents of any two variables.  Sort: This example involves two files ◦ sort.cpp : three template functions, making up a generic version of a selection sort algorithm for an array. Contains a sort() function along with two helper functions ◦ cpp : a main program that uses the sort function.  cpp : a template class called Pair, for storing any pair of values (of the same type). Simple class with basic mutator and accessor functionality.  PFArray : This template class example involves the following 3 files ◦ pfarray.h : header file, declarations for PFArray class. This class stores a dynamically allocated array (of type to be specified). ◦ pfarray.cpp : implementation file for the class (member function definitions) ◦ cpp : sample main program that uses the PFArray template. Creates one instantiation with int and one instantiation with string.  PFArrayBak : This template class (with inheritance) example involves the following 3 files. ◦ pfarraybak.h : header file for a class that is derived from the PFArray class above. Allows storage of a backup copy of the array, with restore capability. ◦ pfarraybak.cpp : implementation file for the class (member function definitions) ◦ cpp : sample main program that uses the PFArrayBak template. Illustrates class features with an instantiation using type string.

 Bitwise AND Operator: &  The bitwise AND operator (&) compares each bit of the first operand to the corresponding bit of the second operand.  If both bits are 1, the corresponding result bit is set to 1. Otherwise, the corresponding result bit is set to 0.

 Bitwise AND Operator: & & =

 Bitwise OR Operator: |  The bitwise inclusive OR operator (|) compares each bit of its first operand to the corresponding bit of its second operand.  If either bit is 1, the corresponding result bit is set to 1. Otherwise, the corresponding result bit is set to 0.

 Bitwise OR Operator: | | =

 Bitwise Exclusive OR Operator: ^  The bitwise exclusive OR operator (^) compares each bit of its first operand to the corresponding bit of its second operand.  If one bit is 0 and the other bit is 1, the corresponding result bit is set to 1. Otherwise, the corresponding result bit is set to 0.

 Bitwise Exclusive OR Operator: ^ ^

 Unary NOT Operator: ~  The bitwise NOT, or complement, is a unary operation that performs logical negation on each bit, forming the ones' complement of the given binary value. Digits which were 0 become 1, and vice versa

CHEESE = 1 // SAUSAGE= 2 // PEPPERONI = 4 // HAM = 8 // MUSHROOMS= 16 // OLIVES = 32 // ONIONS = 64 // PEPPERS = 128 //

 Setting bits  To set a bit, we use the OR operator, like so: PizzaFlags = PizzaFlags OR CHEESE OR PEPPERONI OR ONIONS  Using "OR" may seem counter-intuitive at first – doesn't "and" mean to put two things together? – but you must remember that it only works this way when comparing values. When setting values, the "opposite" is true, in the sense that writing is the "opposite" of reading

 Setting bits //Initial state OR //CHEESE bit OR //PEPPERONI bit OR //ONIONS bit //Final result

 Unsetting bits  To unset a bit, you must combine two operators, AND and NOT. NOT will reverse the bits in the flag, and AND will unset the one 0 bit while leaving the others alone. Let's say that in the previous example, we wanted to unset the ONIONS bit.

 Unsetting bits NOT //ONIONS bit //Inverse of ONIONS bit //Initial state AND //Inverse of ONIONS bit //ONIONS bit unset

 Toggling bits  What if you wanted to flip a bit back and forth each time, without having to check its state? That's where the XOR operator comes in handy. Although this has no practical value in the above pizza example, you can use XOR to flip the ONIONS bit back and forth.

 Toggling bits //Initial state XOR //ONIONS bit //ONIONS bit toggled "off" //Initial state XOR //ONIONS bit //ONIONS bit toggled "on"