CSC 330 Object Oriented Design. Namespaces

Transcription

1 CSC 330 Object Oriented Design Namespaces 1

2 Introduction C++ was developed in early 1980s by Bjarne Stroustrup (AT&T). It was formulated by adding object oriented (and other) features to C, and removing a few bad C features. The primary inspiration came from the language Simula 67. The first commercial release of C++ was in

3 9.2 Namespaces A namespace is a collection of name definitions, such as class definitions and variable declarations If a program uses classes and functions written by different programmers, it may be that the same name is used for different things Namespaces help us deal with this problem 3

4 4 namespaces Program has identifiers in different scopes Sometimes scopes overlap, lead to problems Namespace defines scope Place identifiers and variables within namespace Access with namespace_name::member Note guaranteed to be unique namespace Name { contents Unnamed namespaces are global Need no qualification Namespaces can be nested 4

5 Example 5

6 Accessing the Variables 6

7 using Declaration or namespace cont d 7

8 8 namespaces using statement using namespace namespace_name; Members of that namespace can be used without preceding namespace_name:: Can also be used with individual member Examples using namespace std Discouraged by some programmers, because includes entire contents of std using namespace std::cout Can write cout instead of std::cout 8

9 using Declarations and Directives To avoid the tedium of std::cout << "Please enter stuff \n"; you could write a using declaration using std::cout; // when I say cout,, I mean std::cout cout << "Please enter stuff \n"; // ok: std::cout cin >> x; // error: cin not in scope or you could write a using directive using namespace std; // make all names from namespace std available cout << "Please enter stuff \n"; // ok: std::cout cin >> x; // ok: std::cin 99

10 Namespaces A namespace is a named scope The :: syntax is used to specify which namespace you are using and a which (of many possible) objects of the same name you are referring to For example, cout is in namespace std,, you could write: std::cout << "Please enter stuff \n"; 10 10

11 1 2 // Demonstrating namespaces. 3 #include <iostream> 4 5 using namespace std; // use std namespace 6 7 int integer1 = 98; // global variable 8 9 // create namespace Example 10 namespace Example { // declare two constants and one variable 13 const double PI = ; 14 const double E = ; 15 int integer1 = 8; void printvalues(); // prototype // nested namespace 20 namespace Inner { // define enumeration 23 enum Years { FISCAL1 = 1990, FISCAL2, FISCAL3 ; // end Inner // end Example Note the using statement. This includes all of std, allowing us to use cout and endl. Create a new namespace, Example. Note that it has a variable integer1, different from the global integer1. Note the nested namespace Inner

12 28 29 // create unnamed namespace 30 namespace { 31 double doubleinunnamed = 88.22; // declare variable // end unnamed namespace int main() 36 { 37 // output value doubleinunnamed of unnamed namespace 38 cout << "doubleinunnamed = " << doubleinunnamed; // output global variable 41 cout << "\n(global) integer1 = " << integer1; // output values of Example namespace 44 cout << "\npi = " << Example::PI << "\ne = " 45 << Example::E << "\ninteger1 = " 46 << Example::integer1 << "\nfiscal3 = " 47 << Example::Inner::FISCAL3 << endl; Example::printValues(); // invoke printvalues function return 0; // end main Create an unnamed namespace. Its variables are global

13 54 55 // display variable and constant values 56 void Example::printValues() 57 { 58 cout << "\nin printvalues:\ninteger1 = " 59 << integer1 << "\npi = " << PI << "\ne = " 60 << E << "\ndoubleinunnamed = " << doubleinunnamed 61 << "\n(global) integer1 = " << ::integer1 62 << "\nfiscal3 = " << Inner::FISCAL3 << endl; // end printvalues 13 13

14 doubleinunnamed = (global) integer1 = 98 PI = E = integer1 = 8 FISCAL3 = 1992 In printvalues: integer1 = 8 PI = E = doubleinunnamed = (global) integer1 = 98 FISCAL3 = fig22_03.c pp output (1 of 1) 14

15 Name Conflicts If the same name is used in two namespaces The namespaces cannot be used at the same time Example: If my_function is defined in namespaces ns1 and ns2, the two versions of my_function could be used in one program by using local using directives this way: { using namespace ns1; my_function( ); { using namespace ns2; my_function( ); 15

16 Namespaces Consider this code from two programmers Jack and Jill class Glob { /* */ */ ; // in Jack s s header file jack.h class Widget { /* */ */ ; // also in jack.h class Blob { /* */ */ ; // in Jill s s header file jill.h class Widget { /* */ */ ; // also in jill.h #include "jack.h" jack.h"; // this is in your code #include "jill.h" jill.h"; // so is this void my_func(widget p) // oops! error: multiple definitions of Widget { // 16 16

17 Namespaces The compiler will not compile multiple definitions; such clashes can occur from multiple headers. One way to prevent this problem is with namespaces: namespace Jack { // in Jack s s header file class Glob{ /* */ */ ; class Widget{ /* */ */ ; #include "jack.h" jack.h"; // this is in your code #include "jill.h" jill.h"; // so is this void my_func(jack::widget p) // OK, Jack s s Widget class will not { // clash with a different Widget // 17 17

18 Name Spaces Definition A namespace is an encapsulation unit used to group declarations and definitions with a common scope. Namespaces can encapsulate the following kinds of declarations: Constant and variable declarations Struct, union, and class declarations Function prototypes Function definitions Nested namespaces. 18

19 Namespaces cont d There are three kinds of namespaces: Global namespace: an anonymous namespace composed of all non-static external declarations that do not belong to any other named or unnamed namespace. Select visibility is enabled via the anonymous scope resolution operator (::identifier). Translation unit (TU) namespaces: unnamed namespaces defined within a file; they limit the scope of external declarations to the given file; each file defines a unique TU namespace (if declared); TU namespaces obviate the need for global static declarations; declarations in TU namespaces and global declarations are indistinguishable within the same file only global declarations can have visibility outside the file in which they are defined. Select visibility is enabled via the anonymous scope resolution operator (::). Named namespaces: have an associated identifier that must be unique among all named namespaces. Select visibility is enabled via the scope resolution operator (namespace-id::identifier). 19

20 Namespaces USES 1. To organize a group of modules for independent and parallel develop by different teams (or individuals). By limiting the scope of names to the namespace, naming conflicts can be avoided when independently developed namespaces are integrated after development. 2. To organize a group of related classes that have a common purpose in the design. For example, subsystems may be encapsulated by namespaces. 3. To implement one-of-a-kind objects (efficiently) without having to create the extra overhead associated with defining classes and restricting the number of instances that can be created. 20

21 Name Spaces Global Namespace Translation Unit Namespace (one per file) Translation Unit Namespace (one per file) Translation Unit Namespace (one per file) Named Namespace Named Namespace Named Namespace 21

22 Named namespaces One file namespace alpha { int One; typedef int *INTPTR; INTPTR copyint( int value ) { One = value; INTPTR p = new int(one); return p; //copyint //alpha The namespace alpha is directly visible it is declared in the global namespace. int main() { alpha::intptr p; int x = 25; p = alpha::copyint(x); Names defined within alpha must be referenced using the scope resolution operator (::), since they are not directly (globally) visible. 22

23 Named namespaces Three files NOTE: The 3-file approach is preferred. #include "alpha.h" int main() { alpha::intptr p,q; int x = 25; p = alpha::copyint(x); q = alpha::copyint(alpha::one); alpha.h #ifndef ALPHA #define ALPHA namespace alpha { extern int One; //data declaration typedef int *INTPTR; INTPTR copyint( int value ); //fn decl. //alpha #endif alpha.cpp #include alpha.h namespace alpha { int One; //data definition typedef int *INTPTR; INTPTR copyint( int value ) { //fn defn One = value; INTPTR p = new int(one); return p; //copyint //alpha 23

24 File1.cpp #include <iostream> #include <string> using namespace std; #include alpha.h void f( float ); // global fn prototype; int main() { alpha::intptr p; int x = 25; p = alpha::copyint(x); cout << p = << *p << endl; cout << alpha::one = << alpha::one << endl; f( float(x)); // type conversion Namespace Extension File2.cpp #include <iostream> #include <string> using namespace std; namespace alpha { typedef float *FLTPTR; float Two = 0.0; FLTPTR copyflt( float value ) { //fn defn Two = value; FLTPTR p = new float(two); return p; //copyflt //alpha An extension to alpha File2.cpp Local to File2.cpp //code that uses the local extensions to alpha 24

25 Namespace Extension Alpha.h #ifndef ALPHA #define ALPHA namespace alpha { extern int One; //data declaration typedef int *INTPTR; INTPTR copyint( int value ); //fn decl. Any other files that need to reference Information defined in namespace Alpha Only need to include Alpha.h to gain use of features contributed by both File1.cpp and File2.cpp extern float Two; //data declaration typedef int *FLTPTR; FLTPTR copyflt( float value ); //fn decl. //alpha #endif 25

26 TU namespaces File1.cpp #include <iostream> #include <string> #include <math> using namespace std; extern double pi; //defined in another file double h( double ), h2(double); namespace { // scope limited to this file double f( double x) { return x * sqrt(x) //f //namespace double g(double x){ // global namespace return sqrt(x)/x; //g int main() { double y = 25.0*pi; cout << y^1.5 = << f(y) << endl; cout << y^-0.5 = << g(y) << endl; // main File2.cpp double g( double ); // refers to g in file 1 namespace { // visible to h() and h2() const double pi = ; double f( double x) { return x * g(x); //f //TU namespace double h( double y) { return y/f(y); //h double h2( double y){ return pi*y*g(y); //h2 This pi hides ::pi and is only visible in File2. Refers to the local pi not ::pi 26

27 Namespace declarations and directives Using Declarations A using declaration adds a specific name declared in a namespace to the local frame where the using declaration is specified. Using Directive A using directive applies to namespaces as a whole, and simply makes all names declared in the namespace directly visible (without the scope resolution operator). namespace beta { int X, Y,Z; int Z; // global Z int main(){ int X = 0; // local X using namespace beta; //directive X++; // local X Y++; // beta::y Z++; // error (::Z or beta::z )? ::Z++; // global Z beta::z++; // beta Z... namespace beta { int X, Y,Z; int Z; // global Z int main(){ int X = 0; // local X using beta::x; //declaration ( error) using beta::y; //declaration ( localizes) using beta::z; //declaration ( hides ::Z) X++; // local X Y++; // beta::y Z++; // beta::z... 27

28 Namespace Aliases namespace alias-name = namespace-id ; namespace beta { int X, Y,Z; namespace delta { float X,Y,Z; int Z; // global Z namespace D = beta::delta; //alias declarations int main(){ int X = 0; // local X using namespace beta; //directive X++; // local X beta::x++; // X in beta Y++; // beta::y using D::Z; //declaration ( hides ::Z and beta::z) Y++; // beta::y Z++; // beta::delta::z D::X++; // beta::delta::x 28

29 Namespaces (More Rules) Data definitions in namespaces If data definitions are intended to be made public (bad practice!), they must be declared extern in the header file and then defined in the implementation file. Data definitions of a primitive type can be defined with initializers in the implementation file. Data definitions of a class or struct type whose memory must be allocated at runtime (e.g. dynamic arrays) must be defined as pointer variables and then dynamically allocated and initialized explicitly by a procedure call during execution (you should define a special procedure (or proceduress) that serves as an initializer for the namespace. 29

30 Object.h Namespaces as Single Objects #include AppError.h namespace Object { // Declare C++ functions representing methods of the namespace object. // At least one of these function must always be defined to properly initialize // the object s environment before any other method can be called. These // initialization functions serve the same purpose as constructors of a class // type. The default initialization method is declared below. void Initialize(); Object.cpp #include Object.h namespace Object { Define encapsulated data members here. Primitive data can be directly initialized. Data members of a Class type may have to be defined as pointers and intialized by the initialization method(s). Special boolean protocol variables may have to be defined to ensure Initialize() method is called before any other methods. void Initialize() { Define the bodies of the functions declared in the header file. The bodies are defined using The same syntax you would use for functions in C, but they have direct visibility to all data members defined at the top of the namespace. 30

31 Concordance.h #ifndef _CONCORD #define _CONCORD #include <iostream> #include <fstream> using namespace std; #include "Word.h" #include "Reference.h" namespace Concordance { void AddWordRef( Word& Wrd, Reference& Ref); void Output( ostream& fout); #endif #include "Word.h" Client Code #include "Reference.h" #include "Concordance.h" int main() { Word aword; Reference aref; Concordance::AddWordRef(aword,aref); Concordance::Output( cout ); Namespaces as Single Objects Concordance.cpp #include <list> using std::list; #include "Concordance.h" #include "Entry.h" namespace Concordance { list<entry> Contents; void AddWordRef( Word& Wrd, Reference& Ref) { for (list<entry>::iterator I = Contents.begin(); I!= Contents.end(); I++) { if( Wrd < I->GetKey() ) {Contents.insert(I,Entry(Wrd,Ref)); return; if( Wrd == I->GetKey() ) {I->AddRef(Ref); return; //for Contents.push_back(Entry(Wrd,Ref)); //AddWordRef void Output( ostream& fout) { for(list<entry>::iterator I = Contents.begin(); I!= Contents.end(); I++) I->Output(fout); //Output //Concordance 31

32 Namespaces cont d #include Object.h int main() {. Object::Initialize(); // Call Object initialization fn Object::Function1( ); // Call Object procedure x = Object::Function2( ); // Call Object function 32

33 Team Development with Namespaces SystemX SubA TeamA Class One Class Two Main SubB TeamB Team1 33

34 Team Development with Namespaces SubA TeamA: Ted Sally Fred Contains all and only the information Ted needs to make public (for other teams and/or other team members) Ted.h Ted.cpp #include SubA.h using namespace SubA; #include SubB.h namespace SubA { //Ted s Code SubA.h Contains all public declarations for namespace SubA. This is used by clients of SubA (other teams) as well as members of Team A. 34

35 Namespaces: Declaring a Function To add a function to a namespace Declare the function in a namespace grouping namespace john1 { void greeting( ); 35

36 Namespaces: Defining a Function To define a function declared in a namespace Define the function in a namespace grouping namespace john1 { void greeting( ) { cout << "Hello from namespace john1.\n"; 36

37 Namespaces: Using a Function To use a function defined in a namespace Include the using directive in the program where the namespace is to be used Call the function as the function would normally be called int main( ) { { using namespace john1; greeting( ); Using directive's scope Example

38 Suppose you have the namespaces below: A Namespace Problem namespace ns1 { Is there an easier way to use both namespaces considering that my_function is in both? fun1( ); my_function( ); namespace ns2 { fun2( ); my_function( ); 38

39 Qualifying Names Using declarations (not directives) allow us to select individual functions to use from namespaces using ns1::fun1; //makes only fun1 in ns1 available The scope resolution operator identifies a namespace here Means we are using only namespace ns1's version of fun1 If you only want to use the function once, call it like this ns1::fun1( ); 39

40 Qualifiying Parameter Names To qualify the type of a parameter with a using declaration Use the namespace and the type name int get_number (std::istream input_stream) istream is the istream defined in namespace std If istream is the only name needed from namespace std, then you do not need to use using namespace std; 40

41 Directive/Declaration (Optional) A using declaration (using std::cout;) makes only one name available from the namespace A using directive makes all the names in the namespace available 41

42 A Subtle Point (Optional) A using directive potentially introduces a name If ns1 and ns2 both define my_function, using namespace ns1; using namespace ns2; is OK, provided my_function is never used! 42

43 A Subtle Point Continued A using declaration introduces a name into your code: no other use of the name can be made using ns1::my_function; using ns2::my_function; is illegal, even if my_function is never used 43

44 Global or unnamed? Names in the global namespace have global scope (all files) They are available without a qualifier to all the program files Names in the unnamed namespace are local to a compilation unit They are available without a qualifier within the compilation unit 44

45 Display 9.5 (1/2) 45

46 Display 9.5 (2/2) 46

47 Display

48 Display 9.7 (1/2) 48

49 Display 9.7 (2/2) 49

50 Display 9.8 (1/2) 50

51 Display 9.8 (2/2) 51