friend and namespace

11

Friends and NamespaceFriends and Namespace

COSC 1567COSC 1567

C++ ProgrammingC++ Programming

Lecture 6

22

ObjectivesObjectives

• 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

ObjectivesObjectives

• Separate Compilation– Encapsulation reviewed– Header and implementation files

• Namespaces– using directives– Qualifying names– Unnamed namespaces– Hiding helping functions– Nested namespaces

33

44

What Are Friends?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

Friend FunctionsFriend 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!

55

Friend FunctionsFriend 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!

8-8-66

77

How to Declare a Function How to Declare a Function as a Friendas 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

88

The Customer ClassThe Customer Class

99


• 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

1010


• 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

1111


• 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

1212

A main() Program Using A main() Program Using the Customer Classthe Customer Class

Ex6-1.cpp

1313

Using a Friend Function to Using a Friend Function to Access Data from Two ClassesAccess 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

1414


• 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

1515


• 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

1616

The applyTransaction() The applyTransaction() FunctionFunction

Friend Function UsesFriend 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

8-8-1717

Friend Function PurityFriend 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

1818

1919

Using a Forward ReferenceUsing 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

2020


• 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

2121

Using a Friend Function Using a Friend Function with Two Classeswith Two Classes

2222

Using a Friend Function Using a Friend Function with Two Classeswith Two Classes

Ex6-2.cpp

2323


• 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

2424


• 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 itselfEx6-3

2525

Two Instances of a Class Two Instances of a Class Using a FriendUsing 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

2626


• You simply create a member function for the CustTransaction class

• The prototype is:

CustTransaction addTransactions (const CustTransaction aPayment);

2727

CustTransaction Class with CustTransaction Class with addTransactions() Member addTransactions() Member

FunctionFunction

Ex6-4.cpp

2828


• 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

2929

CustTransaction Class a Friend FunctionCustTransaction Class a Friend Function

Ex6-5.cpp

3030


• 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

3131

Making a Friend of a Making a Friend of a Member of Another ClassMember 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

3232


• 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

3333

Definitions of CourseRec Definitions of CourseRec and StudentRequestand StudentRequest

3434

Definitions of CourseRec Definitions of CourseRec and StudentRequestand StudentRequest

3535


Ex6-7.cpp

3636


• 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

3737

Making a Friend of Another Making a Friend of Another ClassClass

• 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

Friend ClassesFriend 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

3838

Separate CompilationSeparate 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

3939

Class SeparationClass 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

4343

Encapsulation ReviewedEncapsulation Reviewed

• Encapsulation principle:– Separate how class is used by programmer

from details of class’s implementation

• "Complete" separation– Change to implementation NO impact on

any other programs

• Basic OOP principle

4141

Encapsulation RulesEncapsulation Rules

• Rules to ensure separation:

1. All member variables should be private

2. Basic class operations should be:• Public member functions• Friend or ordinary functions• Overloaded operators

Group class definition and prototypes together• Called "interface" for class

3. Make class implementation unavailable tousers of class

4242

NamespacesNamespaces

• 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

4343

using Directiveusing Directive

• using namespace std;– Makes all definitions in std namespace

available

• Why might you NOT want this?– Can make cout, cin have non-standard

meaning• Perhaps a need to redefine cout, cin

– Can redefine any others

4444

Namespace stdNamespace 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 program

to access names

4545

Global NamespaceGlobal Namespace

• All code goes in some namespace

• Unless specified global namespace– No need for using directive– Global namespace always available– Implied "automatic" using directive

4646

Multiple NamesMultiple 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 at

what time

4747

Specifying NamespacesSpecifying 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

4848

Creating a NamespaceCreating 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

4949

Creating a Namespace Creating a Namespace ExampleExample

• Function declaration:namespace Space1{

void greeting();}

• Function definition:namespace Space1{

void greeting(){

cout << "Hello from namespace Space1.\n";}

}

5050

Ex6-9.cpp

using Declarationsusing Declarations

• Can specify individual names from namespace

• Consider:Namespaces NS1, NS2 existEach have functions fun1(), fun(2)– Declaration syntax:

using Name_Space::One_Name;– Specify which name from each:

using NS1::fun1;using NS2::fun2;

5151

using Definitions and Declarationsusing Definitions and Declarations

• Differences:

– using declaration• Makes ONE name in namespace available• Introduces names so no other uses of name

are allowed

– using directive• Makes ALL names in namespace available• Only "potentially" introduces names

5252

Qualifying NamesQualifying Names

• Can specify where name comes from– Use "qualifier" and scope-resolution operator– Used if only intend one use (or few)

• NS1::fun1();– Specifies that fun() comes from namespace

NS1

• Especially useful for parameters:int getInput(std::istream inputStream);– Parameter found in istream’s std namespace– Eliminates need for using directive or declaration

5353

Naming NamespacesNaming Namespaces

• Include unique string– Like last name

• Reduces chance of other namespaceswith same name

• Often multiple programmers writenamespaces for same program– Must have distinct names– Without multiple definitions of same name

in same scope• Results in error

5454

Unnamed NamespacesUnnamed Namespaces

• Compilation unit defined:– A file, along with all files #included in file

• Every compilation unit has unnamed namespace– Written same way, but with no name– All names are then local to compilation unit

• Use unnamed namespace to keep things "local"

• Scope of unnamed namespace is compilation unit

5555

Global vs. Unnamed NamespacesGlobal vs. Unnamed Namespaces

• Not same

• Global namespace:– No namespace grouping at all– Global scope

• Unnamed namespace:– Has namespace grouping, just no name– Local scope

5656

Nested NamespacesNested Namespaces

• Legal to nest namespacesnamespace S1{

namespace S2{

void sample(){

…}

}

• Qualify names twice:– S1::S2::sample();

5757

Ex6-10.cpp

5858

SummarySummary

• 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 function does not use the class name and the scope resolution operator in the function header

• You can create a function that is a friend to multiple classes

5959

SummarySummary

• 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

• Classes can bestow friendship on functions that are members of other classes

• Bestow friendship on an entire class

– Every function that is a member of the class becomes a friend of the granting class

SummarySummary

• Can separate class definition and implementation separate files– Separate compilation units

• Namespace is a collection of name definitions• Three ways to use name from namespace:

– Using directive– Using declaration– Qualifying

6060

SummarySummary

• Namespace definitions are placedinside namespace groupings

• Unnamed namespace– Used for local name definitions– Scope is compilation unit

• Global namespace– Items not in a namespace grouping at all– Global scope

6161

friend and namespace

Documents