View
222
Download
1
Tags:
Embed Size (px)
Citation preview
11
Generic Generic ProgrammingProgramming
22
Why?Why? Sometimes a datum is just a datumSometimes a datum is just a datum Operate on unrelated data typesOperate on unrelated data types
Container classesContainer classes Equality operatorEquality operator Swap methodSwap method Sorting proceduresSorting procedures
Code reuseCode reuse Build programs from small reusable generic Build programs from small reusable generic
partsparts Avoid copying or reinventing the same codeAvoid copying or reinventing the same code
33
Generic ProgrammingGeneric Programming
Compile time parametersCompile time parameters ImplementationImplementation
Same codeSame code used for different parameter values used for different parameter values Different codeDifferent code generated for different values generated for different values
Generic programming in ML Generic programming in ML Generics in ADAGenerics in ADA Java 1.5 – GJ & PizzaJava 1.5 – GJ & Pizza C++ Standard Template LibraryC++ Standard Template Library Containers and IteratorsContainers and Iterators
44
Generic programmingGeneric programming
Define software components with type parametersDefine software components with type parameters A sorting algorithm has the same structure, regardless of A sorting algorithm has the same structure, regardless of
the types being sortedthe types being sorted Stack primitives have the same semantics, regardless of Stack primitives have the same semantics, regardless of
thethe objects stored on the stack.objects stored on the stack.
Most common use: algorithms on Most common use: algorithms on containerscontainers: : updating, iteration, searchupdating, iteration, search
C modelC model: macros (textual substitution): macros (textual substitution) Ada modelAda model: generic units and instantiations: generic units and instantiations C++ modelC++ model: templates: templates ML and Java 1.5: type inferenceML and Java 1.5: type inference
55
Parameterizing Software Parameterizing Software ComponentsComponents
Construct Construct ParameterParameter Supplying parameterSupplying parameter array values (bounds) declaring objectarray values (bounds) declaring object declaring subtypedeclaring subtype record discriminant object/subtyperecord discriminant object/subtype subprogram values (actuals) calling subprogramsubprogram values (actuals) calling subprogram generic unit types, values generic unit types, values instantiatinginstantiating template classes, values template classes, values instantiatinginstantiating,, specializingspecializing
66
Generics in Ada95Generics in Ada95
• I/O for integer types. Identical implementation, I/O for integer types. Identical implementation, but need separate procedures for strong-typing but need separate procedures for strong-typing reasons.reasons.
genericgeneric typetype Elem Elem is rangeis range <> ; <> ; -- any integer type-- any integer type packagepackage Integer_IO is Integer_IO is procedureprocedure Put (Item : Elem); Put (Item : Elem); ......
77
genericgeneric typetype Elem Elem is privateis private;; -- compile time -- compile time
parameterparameter packagepackage Stacks Stacks isis typetype Stack Stack is privateis private;; procedureprocedure Push (X : Elem; On : Push (X : Elem; On : in outin out Stack); Stack); … … privateprivate typetype Cell; Cell; typetype Stack Stack is accessis access Cell; Cell; -- linked list -- linked list
representationrepresentation typetype Cell Cell is recordis record Val : Elem;Val : Elem; Next : Ptr;Next : Ptr; end recordend record;; endend Stacks; Stacks;
A generic PackageA generic Package
88
InstantiationsInstantiations withwith Stacks; Stacks; procedureprocedure Test_Stacks Test_Stacks isis packagepackage Int_Stack Int_Stack is newis new Stacks (Integer); Stacks (Integer); -- Package for -- Package for
integersintegers packagepackage Float_Stack Float_Stack is newis new Stacks (Float); Stacks (Float); -- Package for -- Package for
floatsfloats S1 : Int_Stack.Stack; S1 : Int_Stack.Stack; -- an integer stack object-- an integer stack object S2 : Float_Stack.Stack;S2 : Float_Stack.Stack; -- a float stack object-- a float stack object use Int_Stack, Float_Stack; use Int_Stack, Float_Stack; -- ok, regular packages-- ok, regular packages beginbegin Push (15, S1); Push (15, S1); -- Int_Stack.Push-- Int_Stack.Push Push (3.5 * Pi, S2);Push (3.5 * Pi, S2); ...... endend Test_Stacks; Test_Stacks;
99
Type parametersType parameters
The generic type declaration specifies the The generic type declaration specifies the classclass of of types for which an instance of the generic will work:types for which an instance of the generic will work:
• type type TT is private; is private; -- any type with assignment (Non--- any type with assignment (Non-limited)limited)
• type type TT is limited private; is limited private; -- any type (no required operations)-- any type (no required operations)• type type TT is range <>; is range <>; -- any integer type (arithmetic -- any integer type (arithmetic
operations)operations)• type type TT is (<>); is (<>); -- any discrete type (enumeration or-- any discrete type (enumeration or
• -- integer)-- integer)• type type TT is digits <>; is digits <>; -- any floating-point type-- any floating-point type• type type TT is delta <>; is delta <>; -- any fixed-point type-- any fixed-point type
• Within the generic, the operations that apply to any type of the Within the generic, the operations that apply to any type of the class can be used.class can be used.
• The instantiation must use a specific type of the classThe instantiation must use a specific type of the class
1010
A generic functionA generic function
genericgeneric type type TT is range <>; is range <>; -- parameter of some integer -- parameter of some integer
typetype typetype ArrArr is arrayis array ( (IntegerInteger range <>) ofrange <>) of T; T; -- parameter is array of those-- parameter is array of those functionfunction Sum_Array (A : Arr)Sum_Array (A : Arr) returnreturn T;T;
-- Body identical to non-generic version-- Body identical to non-generic version functionfunction Sum_array (A : Arr)Sum_array (A : Arr) returnreturn TT isis Result : T := 0; Result : T := 0; -- some integer type, so literal 0 is -- some integer type, so literal 0 is
legallegal beginbegin forfor JJ inin A’rangeA’range looploop -- some array type, so attribute is -- some array type, so attribute is
availableavailable Result := Result + A (J); Result := Result + A (J); -- some integer type, so “+” available.-- some integer type, so “+” available. end loop;end loop; returnreturn ResultResult;; end;end;
1111
Instantiating a generic functionInstantiating a generic function
-- Define types for Apple Production-- Define types for Apple Production typetype Apple Apple is rangeis range 1 .. 2 **15 - 1;1 .. 2 **15 - 1; typetype ProductionProduction is arrayis array (1..12)(1..12) ofof Apple;Apple; -- Define types for Sick Days-- Define types for Sick Days typetype Sick_DaysSick_Days is rangeis range 1..5;1..5; typetype AbsencesAbsences is arrayis array (1 .. 52)(1 .. 52) ofof Sick_Days; Sick_Days;
-- Instantiate definite functions from the generic-- Instantiate definite functions from the generic functionfunction Get_Crop Get_Crop is newis new Sum_array (Apple, Production); Sum_array (Apple, Production); functionfunction Lost_Work Lost_Work is newis new Sum_array (Sick_Days, Absences); Sum_array (Sick_Days, Absences);
1212
Generic private typesGeneric private types
• Only available operations are assignment and Only available operations are assignment and
equalityequality.. genericgeneric typetype TT is privateis private;; procedureprocedure Swap (X, Y :Swap (X, Y : in outin out T);T); procedureprocedure Swap (X, Y :Swap (X, Y : in outin out T)T) isis Temp : Temp : constantconstant T := X; T := X; beginbegin X := Y;X := Y; Y := Temp;Y := Temp; endend Swap; Swap;
1313
Subprogram parametersSubprogram parameters
• A generic sorting routine should apply to any array whose components A generic sorting routine should apply to any array whose components are comparable, i.e. for which an ordering predicate exists. This class are comparable, i.e. for which an ordering predicate exists. This class includes more that the numeric types: includes more that the numeric types:
genericgeneric typetype TT is private;is private; -- type parameter-- type parameter with functionwith function “<“ (X, Y : T) “<“ (X, Y : T) returnreturn Boolean; Boolean; -- subprogram -- subprogram
parameterparameter typetype Arr Arr is arrayis array (Integer (Integer rangerange <>) <>) ofof T; T; -- type parameter-- type parameter procedureprocedure Sort (A : Sort (A : in outin out Arr); Arr);
procedureprocedure Sort(A: Sort(A: in outin out Arr) is Arr) is -- A Procedure Body-- A Procedure Body Min: Index;Min: Index;
Temp : T;Temp : T; -- Using type parameter-- Using type parameter beginbegin
forfor I I in in A’first .. Index’Pred(A’Last) A’first .. Index’Pred(A’Last) looploop Min := I;Min := I;
forfor J J in in Index’Succ(I) .. A’Last Index’Succ(I) .. A’Last looploop if if A(J) < A(Min) A(J) < A(Min) thenthen Min := J; Min := J; end ifend if; ; -- Using subprogram -- Using subprogram
parameterparameter end loopend loop;; Temp := A(I); A(I) := A(Min); A(Min) := Temp; Temp := A(I); A(I) := A(Min); A(Min) := Temp; -- swap-- swap end loopend loop;; endend Sort; Sort;
1414
Supplying subprogram Supplying subprogram parametersparameters
• The actual must have a matching signature, not The actual must have a matching signature, not
necessarily the same name:necessarily the same name:
• -- instantiate ascending and descending sort for integers-- instantiate ascending and descending sort for integers procedureprocedure Sort_Up Sort_Up is newis new Sort (Integer, “<“, …); Sort (Integer, “<“, …); procedureprocedure Sort_Down Sort_Down is newis new Sort (Integer, “>”, … ); Sort (Integer, “>”, … );
• -- instantiate sort by seniority for employees-- instantiate sort by seniority for employees typetype Employee Employee is record .. end recordis record .. end record;; functionfunction Senior (E1, E2 : Employee) Senior (E1, E2 : Employee) returnreturn Boolean; Boolean; functionfunction Rank Rank is newis new Sort (Employee, Senior, …); Sort (Employee, Senior, …);
1515
Value parametersValue parameters
Useful to Useful to parametrizeparametrize containers by size: containers by size: genericgeneric typetype Elem Elem is privateis private; ; -- type parameter-- type parameter Size : Positive;Size : Positive; -- value parameter-- value parameter packagepackage Queues Queues isis typetype Queue Queue is privateis private;; procedureprocedure Enqueue (X : Elem; On : Enqueue (X : Elem; On : in outin out Queue); Queue); procedureprocedure Dequeue (X : Dequeue (X : outout Elem; From : Elem; From : in outin out Queue); Queue); functionfunction Full (Q : Queue) Full (Q : Queue) returnreturn Boolean; Boolean; functionfunction Empty (Q : Queue) Empty (Q : Queue) returnreturn Boolean; Boolean; privateprivate typetype Contents Contents is arrayis array (Natural (Natural rangerange <>) <>) ofof Elem; Elem; -- indefinite-- indefinite typetype Queue Queue is recordis record Front, Back: Natural;Front, Back: Natural; C : Contents (0 .. Size); C : Contents (0 .. Size); -- An array of the specified size-- An array of the specified size endend recordrecord;; endend Queues; Queues;
Small_Integer_Queue_Package Small_Integer_Queue_Package is newis new Queues(Integer, 10); Queues(Integer, 10);
1616
Packages as parametersPackages as parameters
If interface includes a type and its operations, the If interface includes a type and its operations, the parameter can be a single generic package:parameter can be a single generic package:
genericgeneric typetype Real Real is digitsis digits <>; <>; -- any floating type-- any floating type packagepackage generic_complex_types generic_complex_types isis -- complex is a record with two real components-- complex is a record with two real components -- package declares all complex operations: +, -, -- package declares all complex operations: +, -,
Re, Im...Re, Im... endend generic_complex_types; generic_complex_types;
We also want to define a package for We also want to define a package for elementary functionselementary functions (sin, cos, etc.) on complex numbers. We need the complex (sin, cos, etc.) on complex numbers. We need the complex operations, which are parametrized by the corresponding operations, which are parametrized by the corresponding real value.real value.
1717
The instantiation requires an The instantiation requires an instance of the parameterinstance of the parameter
withwith generic_complex_types; generic_complex_types; genericgeneric with packagewith package compl compl is newis new generic_complex_types generic_complex_types
(<>);(<>); packagepackage generic_complex_elementary_functions is generic_complex_elementary_functions is -- trigonometric, exponential, hyperbolic functions.-- trigonometric, exponential, hyperbolic functions. endend generic_complex_elementary_functions; generic_complex_elementary_functions;
Instantiate complex types with Instantiate complex types with long_floatlong_float componentscomponents::
packagepackage long_complex long_complex is newis new generic_complex_type generic_complex_type ((long_floatlong_float););
Instantiate complex functions for Instantiate complex functions for long_complexlong_complex types:types:
packagepackage long_complex_functions long_complex_functions isis newnew generic_complex_elementary_functions generic_complex_elementary_functions
((long_complexlong_complex););
1818
Generics in C++ Generics in C++ (Templates)(Templates)
Template is a parameterized class or function Template is a parameterized class or function definitiondefinition
Compiler creates a separate class or function Compiler creates a separate class or function definition for each unique set of parameters with definition for each unique set of parameters with which it is instantiatedwhich it is instantiated Same code not used for multiple typesSame code not used for multiple types Originally implemented using macrosOriginally implemented using macros
Simple SyntaxSimple Syntax templatetemplate ‘ ‘<<‘ parameters ‘‘ parameters ‘>>’ class_def | func_def’ class_def | func_def Parameters may be types or valuesParameters may be types or values
1919
A Template in C++A Template in C++ templatetemplate < <classclass T> T> classclass Vector { Vector { publicpublic:: Vector (size_t n); Vector (size_t n); // constructor// constructor T& T& operator [ ]operator [ ] (size_t index); (size_t index); // subscript operator// subscript operator privateprivate:: … … // implementation details// implementation details };}; Vector<Vector<intint> V1 (100); > V1 (100); // instantiation// instantiation typedeftypedef Vector<Employee> Dept; Vector<Employee> Dept; // named type // named type
instanceinstance
2020
Class and value parametersClass and value parameters templatetemplate < <classclass T, T, intint i> i> classclass Buffer { Buffer { T v [i]; T v [i]; -- storage for buffer-- storage for buffer intint sz; sz; -- total capacity-- total capacity intint count; count; -- current contents-- current contents publicpublic:: Buffer(Buffer( ) : sz (i) , count (0) { };) : sz (i) , count (0) { }; T read ();T read (); voidvoid write (T elem); write (T elem); }; }; Buffer <Shape, 100> picture; Buffer <Shape, 100> picture; -- instance for a -- instance for a
graphics graphics app.app.
2121
Template hopes for the bestTemplate hopes for the best
templatetemplate < <classclass T> T> classclass List { List { structstruct Link { Link { // for a list node// for a list node Link* pre; Link* pre; // doubly linked// doubly linked Link* succ;Link* succ; T val;T val; Link (Link* p, s, Link (Link* p, s, constconst T& v): pre (p), succ(s), val (v) T& v): pre (p), succ(s), val (v)
{ }; }{ }; } Link * head;Link * head; public:public: voidvoid print_all () { print_all () { forfor (Link*p = head; p; p=p->succ) (Link*p = head; p; p=p->succ) cout << p -> cout << p -> valval << ‘\n’; << ‘\n’;
// operator<< better exist for T!// operator<< better exist for T! };};
2222
Function templatesFunction templates
Instantiated implicitly at point of first Instantiated implicitly at point of first call.call.
templatetemplate < <classclass T> T> voidvoid sort (vector <T>& v) sort (vector <T>& v) {..};{..};
voidvoid testit (vector< testit (vector<intint>& vi) {>& vi) {
sort (vi);sort (vi);
// can also write sort<int> (vi);// can also write sort<int> (vi);
};};
2323
Functions and function Functions and function templatestemplates
Templates and regular functions overload Templates and regular functions overload each othereach other::
templatetemplate < <classclass T> T> classclass complex {…}; complex {…};
templatetemplate < < classclass T> T sqrt (T); T> T sqrt (T); // function template for // function template for any Tany T
templatetemplate < < classclass T> complex <T> sqrt (complex <T>); T> complex <T> sqrt (complex <T>); // // specializationspecialization
double double sqrt (sqrt (doubledouble); ); // regular function// regular function voidvoid testit (complex< testit (complex<doubledouble> cd) {> cd) { sqrt (2); sqrt (2); // sqrt<int>:// sqrt<int>: specialization of templatespecialization of template sqrt (cd); sqrt (cd); // sqrt(<double>(complex<double>): // sqrt(<double>(complex<double>):
specializationspecialization sqrt (2.0); sqrt (2.0); // sqrt (double):// sqrt (double): regular functionregular function };};
2424
Iterators and ContainersIterators and Containers Containers are standard data structures to manage Containers are standard data structures to manage
collectionscollections Arrays, Linked Lists, Balanced Trees, etc.Arrays, Linked Lists, Balanced Trees, etc. Operations include: insert, delete, search, countOperations include: insert, delete, search, count
Standard algorithms over collections use iterators:Standard algorithms over collections use iterators:
templatetemplate < <classclass Coll, Coll, classclass Elem> Iterator { Elem> Iterator { Iterator (Coll over) { ..}; Iterator (Coll over) { ..}; // build iterator for given // build iterator for given
collectioncollection Elem First_Elem (); Elem First_Elem (); // start iteration// start iteration Elem Next_Elem (); Elem Next_Elem (); // move to next element in // move to next element in
collectioncollection boolbool done (); done (); // termination condition// termination condition }; };
2525
Standard Template LibraryStandard Template Library Generic Library for C++Generic Library for C++
Well-structured componentsWell-structured components Orthogonal designOrthogonal design Based on firm theoretical foundationsBased on firm theoretical foundations Efficient implementationEfficient implementation
Components Components Algorithms – define computational proceduresAlgorithms – define computational procedures Containers – manage a set of objectsContainers – manage a set of objects Iterators – means of traversing containers Iterators – means of traversing containers Function Objects – encapsulate functions in Function Objects – encapsulate functions in
objectsobjects Adaptors – adapts components to provide a Adaptors – adapts components to provide a
different interfacedifferent interface
2626
Common Operators Common Operators
STL defines STL defines !=!=, , >>, , >=>=, , <=<= from from ==== and and << templatetemplate < <classclass T> T> inline boolinline bool operator!=operator!= ((constconst T& x, T& x, constconst T& y) { T& y) { returnreturn !(x == y); }!(x == y); }
templatetemplate < < classclass T> T> inline boolinline bool operator>=operator>= ( (constconst T& x, T& x, constconst T& y) { T& y) { returnreturn !(x < y); } !(x < y); }
Programmer only needs to define Programmer only needs to define ==== and and <<
Sound and logically consistent semanticsSound and logically consistent semantics
2727
STL AlgorithmsSTL Algorithms Algorithms operate on iteratorsAlgorithms operate on iterators
Apply a function to every element in a containerApply a function to every element in a containertemplatetemplate < <classclass iter, iter, classclass function> function> voidvoid for_each(iter first, iter last, function f); for_each(iter first, iter last, function f); APL-like Reduction APL-like Reduction templatetemplate < <classclass iter, iter, classclass T, T, classclass bin_op> bin_op> voidvoid accumulate(iter first, iter last, T init, function f); accumulate(iter first, iter last, T init, function f);
OrthogonalOrthogonal Algorithm can operate on any container that Algorithm can operate on any container that
supports basic iteratorssupports basic iterators The actual iterator provided may be more complex The actual iterator provided may be more complex
2828
STL ContainersSTL Containers Sequence, list, dequeue, set, map, string, etc.Sequence, list, dequeue, set, map, string, etc.
Instantiated with type parameterInstantiated with type parametertypedeftypedef list<int> int_list; list<int> int_list;int_list a_list;int_list a_list;
All access is based on iteratorsAll access is based on iterators Containers include standard iterators:Containers include standard iterators:
begin() begin() // returns iterator pointing to first element in container// returns iterator pointing to first element in container end() end() // returns iterator pointing to first location after end of // returns iterator pointing to first location after end of
containercontainer Allows uniform access to all kinds of containersAllows uniform access to all kinds of containers
forfor (c.iterator I = c.begin(); I != c.end(); ++I) { (c.iterator I = c.begin(); I != c.end(); ++I) { … … }}
2929
STL IteratorsSTL Iterators Iterators are a generalization of the semantics of Iterators are a generalization of the semantics of
pointerspointers (and arrays) in C (and arrays) in C Categories of iteratorsCategories of iterators
Input Input OutputOutput ForwardForward BidirectionalBidirectional Random AccessRandom Access
Operations on Iterators include:Operations on Iterators include: =, ==, !=, ++(pre and post), *(dereference)=, ==, !=, ++(pre and post), *(dereference) Bidirectional iterators also support: --(pre and post), +, -, Bidirectional iterators also support: --(pre and post), +, -,
etc. etc.
3030
Function Class and AdaptorsFunction Class and Adaptors Function classes are classes for which the Function classes are classes for which the
operator () is defined, allowing the object itself to operator () is defined, allowing the object itself to be called as a functionbe called as a function // A function of type int // A function of type int bool bool unary_function<int, bool> unary_function<int, bool>
// A function of type (int x int) // A function of type (int x int) bool bool binary_function<int, int, bool>binary_function<int, int, bool>
Adaptors allow a particular interface to be Adaptors allow a particular interface to be wrapped around an object.wrapped around an object. Stack adaptor can be supported by a vector, list or Stack adaptor can be supported by a vector, list or
deque.deque. Stack<vector> myStack;Stack<vector> myStack;
3131
Using STLUsing STLmainmain (int argc, char *argv[]) { (int argc, char *argv[]) { int *last; int *last; // integer iterator// integer iterator int result;int result; int test_seq[20];int test_seq[20]; // space for test data// space for test data last = test_seq + 20;last = test_seq + 20; ostream_iterator<int> out_stream(cout, “”);ostream_iterator<int> out_stream(cout, “”); // use generic library functions, such as IotaGen (like APL // use generic library functions, such as IotaGen (like APL
iota) to generate test dataiota) to generate test data generate(test_seq, last, IotaGen<int>(0));generate(test_seq, last, IotaGen<int>(0)); copy(test_seq, last, out_stream);copy(test_seq, last, out_stream); // output: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19// output: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 result = accumulate(test_seq, last, 0);result = accumulate(test_seq, last, 0); cout << result << endl;cout << result << endl; // 190// 190}}
3232
GJ and PizzaGJ and Pizza Added ML style Generics to JavaAdded ML style Generics to Java
Based on type inference in MLBased on type inference in ML Ensures no run-time errorsEnsures no run-time errors Allows same code to execute for different Allows same code to execute for different
typestypes Syntax similar to C++ TemplatesSyntax similar to C++ Templates Compatible with legacy JavaCompatible with legacy Java New Container LibrariesNew Container Libraries Based on GJ and PizzaBased on GJ and Pizza
Research at Bell Labs and ElsewhereResearch at Bell Labs and Elsewhere Phillip WadlerPhillip Wadler
3333
Generic JavaGeneric Java Bad old ugly JavaBad old ugly Java
VectorVector v = v = newnew VectorVector(10);(10); v.put(Integer(9));v.put(Integer(9)); v.put(String(“abc”));v.put(String(“abc”)); StringString s = (String) v.get(n); s = (String) v.get(n); // Run-time error if // Run-time error if
object is not a string!object is not a string! Good new elegant Java 1.5Good new elegant Java 1.5
Vector<String>Vector<String> v = v = newnew Vector<String>Vector<String>(10);(10); v.put(Integer(9)); v.put(Integer(9)); // Compile time error// Compile time error v.put(String(“abc”));v.put(String(“abc”)); StringString s = v.get(n); s = v.get(n); // No cast required// No cast required
3434
Creating Generic ClassesCreating Generic Classespublicpublic classclass Stack<T> { Stack<T> { Vector<T> store;Vector<T> store; // Actual storage structure// Actual storage structure
publicpublic Stack(int n) {store = Stack(int n) {store = newnew Vector<T>(n);} Vector<T>(n);}publicpublic Stack() {store = Stack() {store = newnew Vector<T>(10);} Vector<T>(10);}
publicpublic void Push(T e) { store.add(e);} void Push(T e) { store.add(e);} // Only accepts elements of // Only accepts elements of type Ttype T
publicpublic T Pop() { T Pop() { // Returns type T// Returns type T ifif (store.isEmpty()) { (store.isEmpty()) { throw newthrow new StackEmptyException() StackEmptyException() } } elseelse { { returnreturn remove(store.size-1); remove(store.size-1);} } }} } }
3535
Using Generic ClassesUsing Generic Classes
Stack<int> si; Stack<int> si; // Create an integer stack// Create an integer stack Stack<String> ss;Stack<String> ss;
si.push(4); si.push(4); // OK, si is integer stack// OK, si is integer stack ss.push(“Hello”); ss.push(“Hello”); // OK, ss is string stack// OK, ss is string stack ss.push(3); ss.push(3); // Compile time error// Compile time error
int i = si.pop(); int i = si.pop(); // No cast, no runtime error// No cast, no runtime error