Upcoming SlideShare
×

# CPP08 - Pointers

220 views

Published on

This is an introductory lecture on C++, suitable for first year computing students or those doing a conversion masters degree at postgraduate level.

Published in: Software, Technology, Education
0 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

• Be the first to like this

Views
Total views
220
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
6
0
Likes
0
Embeds 0
No embeds

No notes for slide

### CPP08 - Pointers

1. 1. Pointers Michael Heron
2. 2. Introduction • One of the trickiest things in C++ to get your heads around is the topic of pointers. • I want to introduce this subject early so it doesn’t become a huge problem down the line. • We don’t need to do an awful lot of pointer work at the moment. • We’ll need to do more in the future. • Pointers eventually become second nature. • Honest
3. 3. Cube Calculator #include <iostream> using namespace std; void calculate_cube (int num) { num = num * num * num; } int main() { int num = 5; calculate_cube(num); cout << "Cube is " << num << endl; return 1; }
4. 4. Cube Calculator • What will the output of this program be? • We create a variable • We pass that variable to our function • We make that variable equal the cube of itself. • It seems like the answer should be 125… • … but it won’t be. • Why?
5. 5. Functions and Variables • We have spoken about functions in an earlier lecture. • And how we can provide information to functions by passing parameters. • When we do this, what we pass into the function is a copy of the data we have. • So we really have two versions of the same data in the program at any one time.
6. 6. Functions and Variables • In our calculate_cube function, we are working with a copy of num. • We are never directly manipulating the value of num itself. • This is known as passing by value. • We pass the value of a variable, not the variable itself. • Every variable in C++ is stored in the computer’s memory. • Sometimes we want to be able to get to that memory location. • We want to pass things by reference.
7. 7. Pointers • Here is where the pointer enters our discussion. • It points to a memory location. • Pointers come with two new syntax elements to learn. • & which is the reference operator • * which is the dereference operator. • We use these to swap between the memory location and the value of a memory location.
8. 8. Reference Operator • The & symbol is our reference operator. • You can think of it as meaning ‘the address of’ • We can use this to say ‘I want to send a memory location into this function’: int main() { int num = 5; calculate_cube(&num); cout << "Cube is " << num << endl; return 1; }
9. 9. Dereference Operator • * is the dereference operator • Think of it as ‘the value of’ • We also use this to indicate that a variable is going to be a pointer. • When we accept the parameter we are given, we want to be able to indicate we are working with a pointer. • We need to change our function a little to accommodate that:
10. 10. Our Program With Pointers #include <iostream> using namespace std; void calculate_cube (int *num) { *num = *num * *num * *num; } int main() { int num = 5; calculate_cube(&num); cout << "Cube is " << num << endl; return 1; }
11. 11. How Do They Work? • Every variable takes up a certain amount of memory. • This varies from type to type. • Each variable has a memory address. • That’s how the computer knows where to find it in memory. • A pointer is a location in memory that contains the memory address of another location. • This is known as indirection.
12. 12. Alternative Syntax #include <iostream> using namespace std; void calculate_square (int &num) { num = num * num; } int main() { int num = 5; int num2 = 10; calculate_square (num2); cout << "Square is " << num2 << endl; return 1; }
13. 13. Do We Want Them? • Yes and no. • They are invaluable for doing certain things. • They are overly complex for many requirements. • Far better method in most cases to avoid the use of pointers and make use of return values. • This is not possible in all situations. • When in doubt, try to think of a way to avoid using a pointer.
14. 14. Why Use Pointers? • Very efficient. • Copying values, especially things like objects, is very costly. • More on this in a later lecture. • Permits functions that return more than one value. • Canonical example of this is a function that swaps the contents of two variables. • Resolves some issues of data persistance. • Introduces others along the way…
15. 15. Why Not Use Pointers? • Additional complexity of code. • Code that uses pointers is almost always more complex. • Easy to make mistakes. • Pointers let you work with the live ammo of memory addresses. • You can easily manipulate the memory location rather than the memory contents. • Permits unintended side effects. • Largely negates the issue of scope.
16. 16. Alas… • Sometimes, we have to use pointers. • Because C++ is built around the assumption we will be. • We’ll see them used relatively freely when we talk about objects in a couple of weeks. • For various reasons, passing by value is not really appropriate for dealing with objects.
17. 17. Pointer Notation • When we want to represent pointers in diagram form, we use the notation below. • This is a simple representation. • We don’t worry about memory locations • Just the relationship between variables. *ptr Var
18. 18. Pointers Example 1 int main() { int *yPtr, *zPtr; int y, z; y = 10; z = 5; zPtr = &z; yPtr = &y; cout << "Y is " << y << endl; cout << "yPtr is " << yPtr<< endl; cout << "Z is " << z<< endl; cout << "zPtr is " << zPtr<< endl; return 1; }
19. 19. Pointers Example 2 int main() { int *yPtr, *zPtr; int y, z; y = 10; z = 5; zPtr = &z; yPtr = &y; cout << "Y is " << &y << endl; cout << "yPtr is " << *yPtr<< endl; cout << "Z is " << &z << endl; cout << "zPtr is " << *zPtr<< endl; return 1; }
20. 20. Pointers Example 3 int main() { int *yPtr, *zPtr; int y, z; y = 10; z = 5; zPtr = &z; yPtr = zPtr; *zPtr = 20; cout << "yPtr is " << *yPtr<< endl; cout << "zPtr is " << *zPtr<< endl; return 1; }
21. 21. When Working With Pointers • Always be clear of the relationship between variables. • Draw diagrams if needed • Always be sure of where your pointers are actually pointing. • Remember, the * means ‘the value of my current memory location’ • Be wary of side effects • Very easy to introduce!
22. 22. Summary • C++ has pointers. • Don’t sweat it too much just now… • They are extremely powerful • They let you do things you couldn’t really otherwise do. • They are extremely dangerous. • It’s very easy to lose control of your program by using them. • Be wary!