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 }"

Alban Blankenship
5 years ago
Views:

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

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

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

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

11 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) { }

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

13 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) {

14 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) {

15 typename template <typename ValueType> Vector<ValueType>::iterator 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> typename Vector<ValueType>::iterator Vector<ValueType>::push_back(const ValueType& val) { }

21 size_t string::size() const { // implementation } void string::clear() { // implementation }

22 string Internal State const interface non-const interface void foo(const string& input); void bar(string& input);

23 // constant pointer to a non-constant int int* const p; // non-constant pointer to a constant int const int* p; int const* p; // constant pointer to a constant int const int* const p; int const * const p;

24 // acts like int* const it1; const vector<int>::iterator it1; *it1 = 10; // totally fine! ++it; // can t change iterator // acts like const int* it2; vector<int>::const_iterator it2; *it2 = 10; // can t change element ++it2; // can move iterator

28 const const const

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

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

37 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

38 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

39 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

40 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

41 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

43 This might not always do what you want

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

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

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

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

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

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

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

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

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

56 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);

57 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;

58 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;

59 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;

61 MyVector.pro

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

64 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