Transcription

1

2

3

4

5

6

7

8

9

10 int x = 15; int &reftox = x; reftox = 3; // reftox is a synonym for x cout << x << endl; // prints 3

11 // This function takes a long time to run int findindex(); cout << elems[findindex()] << endl; elems[findindex()].dothings(); elems[findindex()].add(2); // excessive calls to slow function

12 // This function takes a long time to run int findindex(); cout << elems[findindex()] << endl; elems[findindex()].dothings(); elems[findindex()].add(2); // excessive calls to slow function

13 // This function takes a long time to run int indx = findindex(); cout << elems[findindex()] << endl; elems[findindex()].dothings(); elems[findindex()].add(2); // excessive calls to slow function

14 // This function takes a long time to run int indx = findindex(); cout << elems[findindex()] << endl; elems[findindex()].dothings(); elems[findindex()].add(2); // excessive calls to slow function

15 // This function takes a long time to run int indx = findindex(); cout << elems[indx] << endl; elems[indx].dothings(); elems[indx].add(2); // no redundant function calls

16 // This function takes a long time to run int indx = findindex(); cout << elems[indx] << endl; elems[indx].dothings(); elems[indx].add(2); // no redundant function calls Better, but not the best.

17 We can have a reference to the element we want to modify // This function takes a long time to run int indx = findindex(); cout << elems[indx] << endl; elems[indx].dothings(); elems[indx].add(2); // no redundant function calls

18 We can have a reference to the element we want to modify // This function takes a long time to run Foo& curr = elems[findindex()]; cout << curr << endl; curr.dothings(); curr.add(2); // no redundant accessing of elems vector

19 int global = 1; int& getglobal() { return global; int main() { getglobal() += 2; cout << global << endl; // prints 2

20 // REALLY BAD int& getglobal() { int x = 5; return x; int main() { getglobal() += 2; cout << global << endl; // undefined behavioud

21 // REALLY BAD int& getglobal() { int x = 5; return x; int main() { getglobal() += 2; cout << global << endl; Return by reference mostly used with dynamic memory allocation or stream operators // undefined behavioud

22 int x = 3; int& reftox = x; ++reftox; int x = 3; int* reftox = &x; ++(*reftox);

23

24

25 StrVector.pro

26

27 int min(int a, int b) { return (a < b)? a : b;

28 int min(int a, int b) { return (a < b)? a : b; Let s make this general.

29 T min(t a, T b) { return (a < b)? a : b; Some generic type T.

30 template <typename T> T min(t a, T b) { return (a < b)? a : b; s Tell compiler T is a generic type.

31 template <typename T> T min(t a, T b) { return (a < b)? a : b; s Tell compiler T is a generic type. It will replace the parameter for us!

32 class StrVector { public: void push_back(const std::string& elem) ; // rest of implementation

33 class StrVector { public: void push_back(const std::string& elem) ; // rest of implementation

34 class StrVector { public: void push_back(const ValueType& elem) ; // rest of implementation

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

36 MyVector.pro

37

38

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

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

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

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

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

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

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

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

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

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

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

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

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

52

53