Modules Program is built out of components Each component defines a set of logically related entities strong internal coupling A component has a public interface that defines entities exported by the component A component may depend on the entities defined in the interface of another component weak external coupling The component may include other private entities that are not exported Language constructs for modularity Need to declare public interface private implementation dependencies between modules naming conventions of imported entities relationship between modules and files To each his own Ada package declaration and body with clause use clause C header files include directives C header files namespaces include and using declarations directives Java packages import statements Ada Packages package Queues is Size constant Integer 1000 type Queue is private information hiding procedure Enqueue Q in out Queue Elem Integer procedure Dequeue Q in out Queue Elem out Integer function Empty Q Queue return Boolean function Full Q Queue return Boolean function Slack Q Queue return Integer function Q1 Q2 Queue return Boolean overloaded operator private concern of implementation not of client of package end Queues Private parts and information hiding package Queues is visible declarations private type storage is array integer range of integer type queue is record front integer 0 next element to remove back integer 0 next available slot contents storage 0 Size 1 the actual contents Num Integer 0 end record end Queues Client can only use visible interface with Queues use Queues with Text IO procedure Test is Q1 Q2 Queue local objects of a private type Val Integer begin Enqueue Q1 200 visible operation for J in 1 25 loop Enqeue Q1 J Enqueue Q2 J end loop Deqeue Q1 Val visible operation if Q1 Q2 then Text IO Put Line lousy implementation end if end Test Implementation Package body holds bodies of subprograms that implement interface Package may not require a body package Days is type Day is Mon Tue Wed Thu Fri Sat Sun subtype Weekday is Day range Mon Fri Tomorrow constant array Day of Day Tue Wed Thu Fri Sat Sun Mon Next Work Day constant array Weekday of Weekday Tue Wed Thu Fri Mon end Days Implementation of Queues package body Queues is procedure Enqueue Q in out Queue Elem Integer is begin if Full Q then need to signal error raise exception else Q Contents Back Elem end if Q Num Q Num 1 Q Back Q Back 1 mod Size end Enqueue Predicates on queues function Empty Q Queue return Boolean is begin return Num 0 client cannot query Num directly end Empty function Full Q Queue return Boolean is begin return Num Size end Full function Slack Q Queue return Integer is begin return Size Num end Slack Operator Overloading function Q1 Q2 Queue return Boolean is begin if Q1 Num Q2 Num then return False else for J in 1 Q1 Num loop check corresponding elements if Q1 Contents Q1 Front J 1 mod Size Q2 Contents Q2 Front J 1 mod Size then return False end if end loop return True all elements check equal end if end operator is implicitly declared as the negation Syntactic sugar use clauses Visible part of package is akin to record visible entities can be denoted with an expanded name with text io text io put line no ambiguity here package L IO is new text io Integer Io Long Integer Use clause makes name of entity directly usable with text io use text io put line clear enough Sugar can be indispensable with queues procedure test is Q1 Q2 Queues Queue if Q1 Q2 then error is not directly visible must write instead Queues Q1 Q2 Two solutions use queues use type queues queue import all entities import operators only C namespaces Late addition to the language An entity requires one or more declarations and a single definition A namespace declaration can contain both but definitions may also be given separately namespace Nam int f int declaration of f int Nam f int definition provides body of function Dependencies between modules in C Files have semantic significance include directives means textual substitution of one file in another Convention is to use header files for shared interfaces The argument of an include directive need not be a namespace but often is include iostream import declarations int main std cout C is really different n the standard library can always be named Header files are visible interfaces namespace Stack void push char char pop in file stack h include stack h import into some client file void f Stack push c if Stack pop c error impossible Implementation of namespace include stack h import declaration into implementation namespace Stack the definition const int max size 200 char v max size int top 1 void Stack push char c throw exception if top maxsize 1 else insert v top char Stack pop throw exception if top 1 else return v top Syntactic sugar using declarations namespace queue works on single queue void enqueue int int dequeue include queue h in client file using queue dequeue selective a single entity void f queue enqueue 10 prefix needed for enqueue queue enqueue 999 if dequeue 10 but not for dequeue error buggy implementation Wholesale import the using directive include queue h in client file using namespace queue import everything void f enqueue 10 prefix not needed enqueue 999 if dequeue 10 for anything error buggy implementation Visibility the Koenig device When an unqualified name is used as the postfix expression in a function call expr call other namespaces not considered during the usual unqualified look up basic lookup unqual may be searched this search depends on the types of the arguments For each argument type T in the function call there is a set of zero or more associated namespaces to be considered The set of namespaces is determined entirely by the types of the function arguments Type def names used to specify the types do not contribute to this set The set of namespaces are determined in the following way The Koenig device details If T is a fundamental type its associated set of namespaces is empty If T is a class type its associated namespaces are the namespaces in which the class and its direct and indirect base classes are defined If T is a union or enumeration type its associated namespace is th namespace in which it is defined If T is a pointer to U a reference to U or an array of U its associated namespaces are the namespaces associated with U If T is a pointer to function type its associated namespaces are the namespaces associated with the function parameter