1 / 61

Friends and Namespace

Lecture 6. Friends and Namespace. COSC 1567 C++ Programming. Objectives. What a friend is Declare a friend function Use a friend function with data from two classes Use a forward reference Use a friend function with two or more instances of the same class

margueritel
Download Presentation

Friends and Namespace

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 6 Friends and Namespace COSC 1567 C++ Programming

  2. Objectives • What a friend is • Declare a friend function • Use a friend function with data from two classes • Use a forward reference • Use a friend function with two or more instances of the same class • bestow friendship on functions that are members of other classes • Bestow friendship on an entire class

  3. Objectives • Separate Compilation • Encapsulation reviewed • Header and implementation files • Namespaces • using directives • Qualifying names • Unnamed namespaces • Hiding helping functions • Nested namespaces

  4. What Are Friends? • A friend function is a function that can access private data members of a class, even though the function itself is not a member of the class • A friend class is a class whose functions can all access private data members of another class • A friend function can access private data from a class of which it is not a member, but a friend function cannot be a friend on its own • The friend relationship is always one-sided

  5. Friend Functions • Nonmember functions • Recall: operator overloads as nonmembers • They access data through accessor and mutatorfunctions • Very inefficient (overhead of calls) • Friends can directly access private class data • No overhead, more efficient • So: best to make nonmember operatoroverloads friends!

  6. Friend Functions • Friend function of a class • Not a member function • Has direct access to private members • Just as member functions do • Use keyword friend in front of function declaration • Specified IN class definition • But they’re NOT member functions!

  7. How to Declare a Function as a Friend • The class contains data fields for a customer number and balance • The class contains three functions; two are members of the class • The default constructor for the Customer class supplies values for the data fields if none are provided when a Customer object is instantiated

  8. The Customer Class

  9. How to Declare a Function as a Friend • As a member of the Customer class, the displayCustomer() function meets the following conditions: • Requires the class name Customer and the scope resolution operator in the function header • Must have access to the private fields custNum and balanceDue • Must be declared in the public section of the class definition, so that a main() program (or any other client function) can use it

  10. How to Declare a Function as a Friend • The function displayAsAFriend() is not a Customer member function • It must meet the following conditions: • Cannot use the class name Customer and the scope resolution operator in the function header • Need not be declared in the public section of the class definition • Must use the C++ keyword friend in its declaration

  11. How to Declare a Function as a Friend • When any function tries to access an object’s private data member, the compiler examines the list of function prototypes in the class declaration, and one of three things happens: • The function is found to be a member function, and access is approved • The function is found to be a friend function, and access is approved • The function is not found to be a member or a friend, and access is denied; you receive an error message

  12. A main() Program Using the Customer Class Ex6-1.cpp

  13. Using a Friend Function to Access Data from Two Classes • Figure 7-3 shows the definition section of a CustTransaction class • You might create a CustTransaction object for each customer transaction, such as a purchase of an item, payment on an account, or return of an item

  14. Using a Friend Function to Access Data from Two Classes • If you create a function that performs the payment application operation, you have at least five choices (although four of these are inferior choices): • You can make the balanceDue field in the Customer class public, and the paymentAmount field in the CustTransaction class public • If you create a payment application function that is not a member of either the Customer or the CustTransaction class, the function will not have access to the private data fields of either class

  15. Using a Friend Function to Access Data from Two Classes • The choices continued: • If you make the payment application function a member of the Customer class, the function has access to balanceDue, but not to paymentAmount, which is private within the CustTransaction class • If you make the payment application function a member of the CustTransaction class, the function has access to paymentAmount, but not to balanceDue, which is private within the Customer class • You can make the payment application function a friend of both classes

  16. The applyTransaction() Function

  17. Friend Function Uses • Operator Overloads • Most common use of friends • Improves efficiency • Avoids need to call accessor/mutatormember functions • Operator must have access anyway • Might as well give full access as friend • Friends can be any function

  18. Friend Function Purity • Friends not pure? • "Spirit" of OOP dictates all operators and functions be member functions • Friends violate basic OOP principles • Advantageous? • For operators: very! • Allows automatic type conversion • Still encapsulates: friend is in class definition • Improves efficiency

  19. Using a Forward Reference • To use the applyTransaction() function as a friend to both the Customer and the CustTransaction class, you must declare the function as a friend within each class • The declaration of the applyTransaction() function is: friend void applyTransaction(Customer cust, CustTransaction trans); • You already know you must declare a variable before using it

  20. Using a Forward Reference • You also must declare, or prototype, a function before you use it • Similarly, a class must be declared before you use it • A forward reference lets the compiler know that the class exists, and that the details will come later

  21. Using a Friend Function with Two Classes

  22. Using a Friend Function with Two Classes Ex6-2.cpp

  23. Using a Forward Reference • When two classes refer to each other, you can choose to forward declare either one, and then define the other class first • The same principle holds true if three, four, or more classes share a friend function that makes reference to all the classes

  24. Using a Forward Reference • In this case you: • Forward declare all the classes except one • Define the class you did not forward declare, and include the friend function prototype in the class definition • Define all classes that you did forward declare. The forward declared classes will contain the same friend function prototype as the first class you defined • Define the friend function itself Ex6-3

  25. Two Instances of a Class Using a Friend • You can use a friend function to access private data members from objects that belong to two different classes • If you want a function to have access to two or more instances of the same class, you can use either a class member function or a friend function • You can sum two CustTransaction objects without creating a friend function

  26. Two Instances of a Class Using a Friend • You simply create a member function for the CustTransaction class • The prototype is: CustTransaction addTransactions (const CustTransaction aPayment);

  27. CustTransaction Class with addTransactions() Member Function Ex6-4.cpp

  28. Two Instances of a Class Using a Friend • Within addTransactions(), the billingSummary.paymentAmount is set equal to the sum of the invoking object’s (firstTrans) paymentAmount and the passed object’s (secondTrans) payment amount • A copy of the entire, newly constructed and defined billingSummary is returned to the calling function, where totalTrans receives it • One way to avoid a subsidiary transaction is to create a friend function to the CustTransaction class

  29. CustTransaction Class a Friend Function Ex6-5.cpp

  30. Two Instances of a Class Using a Friend • Another example • Create a friend function to compare two Loan objects and determine whether they are equal • Consider two loans equal if they are for the same amount at the same interest rate Ex6-6.cpp

  31. Making a Friend of a Member of Another Class • Classes can bestow friendship on nonmember functions; they also can bestow friendship on functions that are members of other classes • Consider two classes developed for a college registration system • One class is named StudentRequest; it holds a student idNum and a course section in which the student requests enrollment • The other class, named CourseRec, holds information about one section of a course, including a section number, enrollment limit, and current enrollment

  32. Making a Friend of a Member of Another Class • The student enrollment request example shows a class granting friendship to a single function that is a member of another class • Creating the class definitions for the preceding example requires three operations: • Forward declare the class that is granting friendship, because the class that holds the friend will use this class name • Declare the class containing the function that will be a friend • Define the class that is granting friendship

  33. Definitions of CourseRec and StudentRequest

  34. Definitions of CourseRec and StudentRequest

  35. Making a Friend of a Member of Another Class Ex6-7.cpp

  36. Making a Friend of a Member of Another Class • Another example: • Two classes of objects are needed: Courses and Rooms • When a Course section is scheduled, a search is made for a Room that holds the number of students that might enroll Ex6-8.cpp

  37. Making a Friend of Another Class • To grant friendship to an entire class, construct the class definition simply by writing the keyword friend followed by class and the name of the class • When you grant friendship to a class, every function that is a member of the class becomes a friend of the granting class Modify ex6-7.cpp

  38. Friend Classes • Entire classes can be friends • Similar to function being friend to class • Example:class F is friend of class C • All class F member functions are friends of C • NOT reciprocated • Friendship granted, not taken • Syntax: friend class F • Goes inside class definition of "authorizing" class

  39. Separate Compilation • Program Parts • Kept in separate files • Compiled separately • Linked together before program runs • Class definitions • Separate from "using" programs • Build library of classes • Re-used by many different programs • Just like predefined libraries

  40. Class Separation • Class Independence • Separate class definition/specification • Called "interface" • Separate class implementation • Place in two files • If implementation changes  only thatfile need be changed • Class specification need not change • "User" programs need not change

  41. Encapsulation Reviewed • Encapsulation principle: • Separate how class is used by programmerfrom details of class’s implementation • "Complete" separation • Change to implementation  NO impact onany other programs • Basic OOP principle

  42. Encapsulation Rules • Rules to ensure separation: • All member variables should be private • Basic class operations should be: • Public member functions • Friend or ordinary functions • Overloaded operators Group class definition and prototypes together • Called "interface" for class • Make class implementation unavailable tousers of class

  43. Namespaces • Namespace defined:A collection of name definitions • Class definitions • Variable declarations • Programs use many classes, functions • Commonly have same names • Namespaces deal with this • Can be "on" or "off" • If names might conflict  turn off

  44. using Directive • using namespace std; • Makes all definitions in std namespaceavailable • Why might you NOT want this? • Can make cout, cin have non-standardmeaning • Perhaps a need to redefine cout, cin • Can redefine any others

  45. Namespace std • We’ve used namespace std • Contains all names defined in many standard library files • Example:#include <iostream> • Places all name definitions (cin, cout, etc.)into std namespace • Program doesn’t know names • Must specify this namespace for programto access names

  46. Global Namespace • All code goes in some namespace • Unless specified  global namespace • No need for using directive • Global namespace always available • Implied "automatic" using directive

  47. Multiple Names • Multiple namespaces • e.g., global, and std typically used • What if name defined in both? • Error • Can still use both namespaces • Must specify which namespace used atwhat time

  48. Specifying Namespaces • Given namespaces NS1, NS2 • Both have void function myFunction()defined differently { using namespace NS1; myFunction();}{ using namespace NS2; myFunction();} • using directive has block-scope

  49. Creating a Namespace • Use namespace grouping:namespace Name_Space_Name{ Some_Code} • Places all names defined in Some_Codeinto namespace Name_Space_Name • Can then be made available:using namespace Name_Space_Name

  50. Creating a Namespace Example Ex6-9.cpp • Function declaration:namespace Space1{ void greeting();} • Function definition:namespace Space1{ void greeting() { cout << "Hello from namespace Space1.\n"; }}

More Related