Tell compiler ValueType is a generic type. public: void push_back(const ValueType& elem); // rest of implementation }

Size: px

Start display at page:

Download "Tell compiler ValueType is a generic type. public: void push_back(const ValueType& elem); // rest of implementation }"

Ellen Howard
5 years ago
Views:

5 template <typename ValueType> class StrVector { Tell compiler ValueType is a generic type. public: void push_back(const ValueType& elem); // rest of implementation }

7 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } void Vector::push_back(const ValueType& val) { }

8 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } Compiler error void Vector::push_back(const ValueType& val) { }

9 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } void Vector::push_back(const ValueType& val) { }

10 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } void Vector::push_back(const ValueType& val) { }

11 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } void Vector<ValueType>::push_back(const ValueType& val) { }

12 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } Compiler error void Vector<ValueType>::push_back(const ValueType& val) { }

13 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } void Vector<ValueType>::push_back(const ValueType& val) { }

14 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } template <typename ValueType> void Vector<ValueType>::push_back(const ValueType& val) {

15 template <typename ValueType> class Vector { public: void push_back(const ValueType& elem); // rest of implementation } All good! template <typename ValueType> void Vector<ValueType>::push_back(const ValueType& val) {

16 typename template <typename ValueType> Vector<ValueType>::iterator Vector<ValueType>::push_back(const ValueType& val) { }

17 typename template <typename ValueType> Vector<ValueType>::iterator Vector<ValueType>::push_back(const ValueType& val) { }

18 typename template <typename ValueType> Vector<ValueType>::iterator Vector<ValueType>::push_back(const ValueType& val) { }

19 typename template <typename ValueType> typename Vector<ValueType>::iterator Vector<ValueType>::push_back(const ValueType& val) { }

21 const const const

27 Vector<string> defv; // initialisation Vector<string> fillv(10, "hello"); // initialisation Vector<string> copyv(defc); // initialisation Vector<string> v = defv; // initialisation v = fillv; // assignment

29 Vector<string> defv; // initialisation Vector<string> fillv(10, "hello"); // initialisation Vector<string> copyv(defc); // initialisation Vector<string> v = defv; // initialisation v = fillv; // assignment

30 Vector<string> defv; // normal constructor // initialisation Vector<string> fillv(10, "hello"); // initialisation Vector<string> copyv(defc); // initialisation Vector<string> v = defv; // initialisation v = fillv; // assignment

31 Vector<string> defv; // normal constructor // initialisation Vector<string> fillv(10, "hello"); // normal constructor // initialisation Vector<string> copyv(defc); // initialisation Vector<string> v = defv; // initialisation v = fillv; // assignment

32 Vector<string> defv; // normal constructor // initialisation Vector<string> fillv(10, "hello"); // normal constructor // initialisation Vector<string> copyv(defc); // copy constructor // initialisation Vector<string> v = defv; // initialisation v = fillv; // assignment

33 Vector<string> defv; // normal constructor // initialisation Vector<string> fillv(10, "hello"); // normal constructor // initialisation Vector<string> copyv(defc); // copy constructor // initialisation Vector<string> v = defv; // initialisation // copy constructor v = fillv; // assignment

34 Vector<string> defv; // normal constructor // initialisation Vector<string> fillv(10, "hello"); // normal constructor // initialisation Vector<string> copyv(defc); // copy constructor // initialisation Vector<string> v = defv; // initialisation v = fillv; // assignment // copy constructor // copy assingment

36 This might not always do what you want

38 private: int privint; } class MyClass { public: MyClass() { privint = 3; } // default constructor

39 MyClass defc; // calls default constructor MyClass buggy(); // DOESNT WORK!

40 MyClass defc; // calls default constructor MyClass buggy(); // DOESNT WORK!

41 MyClass defc; // calls default constructor // Treated as function declaration MyClass buggy(); // DOESNT WORK! This is called C++ s Most Vexing Parse

43 // vector<string> v created earlier // copy constructor called vector<string> copyv(v); vector<string> copyv2 = v;

44 MyClass::MyClass (const MyClass& rhs) { } // implementation

46 vector<int> a: ElemType* elems; int logicalsize; int allocatedsize; 0 8 Vector<int> a;

47 vector<int> a: ElemType* elems; 8 int logicalsize; int allocatedsize; 1 8 Vector<int> a; a.push_back(8);

48 vector<int> a: ElemType* elems; 8 6 int logicalsize; int allocatedsize; 2 8 Vector<int> a; a.push_back(8); a.push_back(6);

49 vector<int> a: ElemType* elems; int logicalsize; int allocatedsize; 3 8 Vector<int> a; a.push_back(8); a.push_back(6); a.push_back(7);

50 vector<int> a: ElemType* elems; int logicalsize; int allocatedsize; 3 8 vector<int> b: ElemType* elems; int logicalsize; 3 int allocatedsize; 8 Vector<int> a; a.push_back(8); a.push_back(6); a.push_back(7); Vector<int> b = a;

51 vector<int> a: ElemType* elems; int logicalsize; int allocatedsize; Changing the value of b also changed the value of a! vector<int> b: ElemType* elems; int logicalsize; 3 int allocatedsize; 8 Vector<int> a; a.push_back(8); a.push_back(6); a.push_back(7); Vector<int> b = a; b[0] = 9;

52 vector<int> a: ElemType* elems; int logicalsize; int allocatedsize; vector<int> b: ElemType* elems; int logicalsize; 3 int allocatedsize; 8 Vector<int> a; a.push_back(8); a.push_back(6); a.push_back(7); Vector<int> b = a; b[0] = 9;

54 MyVector.pro

56 // vector<string> v, v2 created earlier // copy constructor called vector<string> copyv = v; // copy assignment copyv = v2;

57 class MyClass { public: MyClass& operator=(const MyClass& rhs) { } private: int privint; }

Tell compiler ValueType is a generic type. public: void push_back(const ValueType& elem); // rest of implementation }

template class StrVector { Tell compiler ValueType is a generic type. public: void push_back(const ValueType& elem); // rest of implementation } template class