COMP6771 Advanced C++ Programming

Transcription

1 1. COMP6771 Advanced C++ Programming Week 6 Part Three: cs6771

2 2. Why? In C++, class names cannot be overloaded. Thus: 1 class IntStack { 2 public: 3 void push(int&); 4 void pop(); 5 int& top(); 6 const int& top() const; private: 9 vector<int> stack_; 10 }; 1 class DoubleStack { 2 public: 3 void push(double&); 4 void pop(); 5 double& top(); 6 const double& top() const; private: 9 vector<double> stack_; 10 }; Two drawbacks: The lexical complexity: IntStack, DoubleStack,... Administrative nightmare

3 . What Are? stack.h The interface Stack.h: #ifndef STACK_H #define STACK_H #include <iostream> #include <vector> template <> class Stack; template < T> std::ostream& operator<< (std::ostream &os, const Stack<T> &s); template < T> class Stack { public: friend std::ostream& operator<<<t>(std::ostream &, const Stack<T> &); void push(const T &); void pop(); T& top(); const T& top() const; bool empty() const; private: std::vector<t> stack_; }; #endif A prescription for compiler to generate class types 3

4 . 4 The Stack Implementation: Stack.h 1 template < T> 2 void Stack<T>::push(const T &item) { 3 stack_.push_back(item); 4 } 5 6 template < T> 7 void Stack<T>::pop() { 8 stack_.pop_back(); 9 } template < T> 12 T& Stack<T>::top() { 13 return stack_.back(); 14 } template < T> 17 const T& Stack<T>::top() const { 18 return stack_.back(); 19 } template < T> 22 bool Stack<T>::empty() const { 23 return stack_.empty(); 24 }

5 5. The Stack implementation: Stack.h 1 template < T> 2 std::ostream& operator<<(std::ostream &os, const Stack<T> &s) { 3 for (unsigned int i = 0; i < s.stack_.size(); i++) { 4 os << s.stack_[i] << " "; 5 } 6 return os; 7 }. NB. Ạ friend to a class is part of the class s interface!

6 . 6 1 #include <iostream> 2 3 #include "stack.hpp" 4 Client Code: stack-user.cpp 5 int main() { 6 Stack<int> s1; // int: template argument 7 s1.push(1); 8 s1.push(2); 9 Stack<int> s2 = s1; 10 std::cout << s1 << s2 << std::endl; 11 s1.pop(); 12 s1.push(3); 13 std::cout << s1 << s2 << std::endl; 14 } Use the compiler-generated default ctor stack<int> s; // create an empty stack Use the compiler-generated copy-control members: OK: because C++ STL containers use value semantics Use the compiler-generated dtor (which does nothing) OK: vector s dtor will take care of stack s deallocation

7 7. 1 template < T> 2 Stack<T>::Stack() { } 3 The Default C tor and Big Five 4 template < T> 5 Stack<T>::Stack(const Stack<T> &s) : stack_{s.stack_} { } 6 7 template < T> 8 Stack<T>::Stack(Stack<T> &&s) : stack_(std::move(s.stack_)); { } 9 10 template < T> 11 Stack<T>& Stack<T>::operator=(const Stack<T> &s) { 12 stack_ = s.stack_; 13 } template < T> 16 Stack<T>& Stack<T>::operator=(Stack<T> &&s) { 17 stack_ = std::move(s.stack_); 18 } template < T> 21 Stack<T>:: Stack() { } 22

8 . Inclusion Compilation Model // stack.h: template < T> class Stack {... }; // user-file1.h: #include stack.h Stack<int> s1; Stack<double> s2; // user-file2.h: #include stack.h Stack<int> s3; Stack<char> s4; 8 Program must behave as if only one Stack<int> were instantiated even when it is instantiated multiple times Drawbacks: Implementation details available in Stack.h Compiling the same template many times can be slow

9 9. Class Template Stack<int> s1; // 1 stack<int> instantiated Stack<char> *ps; ps->push( a ); // 2 stack<char> instantiated : the generation of a class from a template On-demand instantiation: a template is instantiated when an object is defined with a type that is a class template 1 and 2 : point of instantiation Lazy instantiation: only member functions used are instantiated (e.g, empty() not instantiated if never called)

10 10. Name Resolution Same two steps as for function templates The member function push modified to: template < T> void Stack<T>::push(const T &item) { std::cout << "value pushed: "; 1 std::cout << item 2 stack_.push_back(item); } Type-independent names are resolved when the template is defined, e.g., operator<< for strings at 1 Type-dependent names are resolved when the template is instantiated, e.g., operator<< for item at 2

11 11. SmallInt Name Resolution class SmallInt { friend ostream& operator<<(ostream &os, const SmallInt &s); public: SmallInt(int v) : value_(v) { } private: int value_; }; << for 2 found Client code: #include "stack.h" #include "SmallInt.h" Stack<SmallInt> s; // point of instantiation std::cout << s;

12 12. No Class Template Argument Deduction Stack s; // which instantiation?

13 13. Conversions for Member Functions Stack<int> s; // instantiates Stack<int> short s = 10; int i = 10; s.push(s); // instantiates Stack<int>::push(const int&) s.push(i); // uses Stack<int>::push(const int&) Unlike function templates, normal conversions are allowed on arguments to function parameters that were defined using the template parameters of the class template However, member templates are still function templates

14 14. Default Arguments Can supply default arguments for template types For instance, if we wanted the user to be able to change the underlying container (defaultargumentstack.hpp): 1 #ifndef DEFAULTARGUMENTSTACK_HPP 2 #define DEFAULTARGUMENTSTACK_HPP 3 4 #include <iostream> 5 #include <deque> 6 7 template <,> class Stack; 8 9 template < T, CONT> 10 std::ostream& operator<< (std::ostream &os, const Stack<T, CONT> &s); template < T, CONT = std::deque<t>> class Stack { 13 public: 14 friend std::ostream& operator<<<t>(std::ostream &, const Stack<T, CONT> &); 15 void push(const T &); 16 void pop(); 17 T& top(); 18 const T& top() const; 19 bool empty() const; 20 private: 21 CONT stack_; 22 };

15 15. Client code: 1 #include<vector> 2 Default Arguments 3 #include "defaultargumentstack.hpp" 4 5 int main() { 6 Stack<int> s1; 7 Stack<int, std::deque<int>> s2 = s1; 8 Stack<int, std::vector<int>> s3; 9 10 s1.push(1); 11 s1.push(2); 12 s2 = s1; 13 // s3 = s1; // OK? - one is a deque and the other is a vector 14 std::cout << s1 << s2 << std::endl; 15 s1.pop(); 16 s1.push(3); 17 std::cout << s1 << s2 << std::endl; 18 }. Will look at template template parameters in the next lecture

16 16. Static Members Each instantiation has its own set of static members Add a static data member to count the no. of stacks created: 1 // staticstack.hpp: 2 static int numstacks_; // declaration inside class declaration 3 4 template < T, CONT> 5 int Stack<T,CONT>::numStacks_ = 0; // definition 6 7 template < T, CONT> inline 8 Stack<T, CONT>::Stack() { numstacks_++; } 9 10 template < T, CONT> inline 11 Stack<T, CONT>:: Stack() { 12 if (numstacks_) 13 std::cout << typeid(this).name() << ": " << numstacks_ 14 << std::endl; 15 numstacks_ = 0; 16 }

17 17. Static Members Client code: 1 #include <vector> 2 3 #include "staticstack.hpp" 4 5 int main() { 6 Stack<float> fs; 7 Stack<int> is1, is2, is3; 8 Stack<int, std::vector<int>> is4; 9 } At the closing }, the destructors are called: P5StackIiSt6vectorIiSaIiEEE: 1 P5StackIiSt5dequeIiSaIiEEE: 3 P5StackIfSt5dequeIfSaIfEEE: 1

18 18. Friend Declarations in Three kinds of friend declarations: Ordinary friend functions/classes Friend template instantiations Friend templates

19 19. Ordinary class Foo { void bar(); }; template < T> class Stack { friend class foobar; friend void foo(); friend void Foo::bar(); }

20 20. Friend Templates Each Manager instantiation has all instantiations of a friend The mapping is one-to-many (unbounded) template < T> class Manager { template < U> friend class Task; template < U> friend class Schedule<U>::dispatch(Task<U>*);... }; No need to give the corresponding template declarations since the friend declarations are treated as template declarations The scope of a friend declaration is exposed to the scope surrounding the class (Chapter 16)

21 21. Friend Template s Each Stack instantiation has one unique instantiation of each friend The mapping is one-to-one (bounded) template < T> class foobar {... } template < T> void foo(stack<t> &); template < T> class Foo { void bar(); } template < T> class Stack { friend class foobar<t>; friend void foo<t>(stack<t>); friend void Foo<T>::bar(); } operator<< in Stack is another example

22 22. The Keyword for nested types template < T> class X { T::id *i; // error without public: void f() { i.g(); } }; class Y { public: class id {... }; }; int main() { X<Y> xy; } Use for a nested type By default, T::id is assumed to be a non-type

23 23. Summary Templates are used extensively in C++ STL They are relatively straightforward to understand But the syntax can be overwhelming initially The error messages can be overwhelming C++ programmers need to be proficient in templates

24 24. Reading Chapter 16, C++ Primer: Chapter 5, Bruce Eckel, Thinking in C++, Vol 2 C++ FAQ Lite: templates: Next Lecture: Templates