1 / 100

CHAPTER 14 POINTERS, CLASSES, LISTS, AND VIRTUAL FUNCTIONS

CHAPTER 14 POINTERS, CLASSES, LISTS, AND VIRTUAL FUNCTIONS. THE POINTER DATA TYPE AND POINTER VARIABLES Pointer variable: A variable whose content is an address— (that is, a memory address). Declaring Pointer Variables The general syntax of declaring a pointer variable is

odell
Télécharger la présentation

CHAPTER 14 POINTERS, CLASSES, LISTS, AND VIRTUAL FUNCTIONS

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CHAPTER 14POINTERS, CLASSES, LISTS, AND VIRTUAL FUNCTIONS

  2. THE POINTER DATA TYPE AND POINTER VARIABLES • Pointer variable: A variable whose content is an address— (that is, a memory address). Declaring Pointer Variables • The general syntax of declaring a pointer variable is dataType *identifier; int *p; char *ch;

  3. The statement int *p; is equivalent to the statement int* p; which is equivalent to the statement int * p; • The character * can appear anywhere between the data type name and the variable name. int* p, q; • Only p is the pointer variable, not q. Here q is an int variable. • To avoid confusion, we prefer to attach the character * to the variable name. int *p, q; • The following statement declares both p and q to be pointer variables of the type int. int *p, *q;

  4. THE ADDRESS OF OPERATOR (&) • In C++, the ampersand, &, called the address of operator, is a unary operator that returns the address of its operand. Given the statements int x; int *p; the statement p = &x; assigns the address of x to p. That is, x and the value of p refers to the same memory location.

  5. THE DEREFERENCING OPERATOR (*) • C++ also uses * as a unary operator. • When used as a unary operator, *, commonly referred to as the dereferencing operator or indirection operator, refers to the object to which its operand (that is, a pointer) points int x = 25; int *p; p = &x; //store the address of x in p The statement cout<<*p<<endl; prints the value of x. Also the statement *p = 55; will store 55 in the memory location pointed to by p, that is, in x.

  6. int *p; int num; • p is a pointer variable of the type int and num is a variable of type int.

  7. num = 78;

  8. p = &num;

  9. *p = 24;

  10. 1. &p, p, and *p all have different meanings. 2. &p means the address of p—that is, 1200 (in Figure 14-4). 3. p means the content of p (1800 in Figure 14-4). 4. *p means the content (24 in Figure 14-4) of the memory location (1800 in Figure 14-4) pointed to by p (that is, pointed to by the content of memory location 1200).

  11. Example 14-1 int *p; int x;

  12. After the statement x = 50;

  13. After the statement: p = &x; • After the statement • *p = 38;

  14. 1. A declaration such as int *p; allocates memory for p only, not for *p. 2. Assume the following: int *p; int x; a. p is a pointer variable; b. Content of p only points to a memory location of the type int; c. Memory location x exists and is of the type int. The assignment p = &x; is legal. After the execution of this statement *p is valid and meaningful.

  15. Example 14-2 //Chapter 14: Example 14-2 #include <iostream> using namespace std; int main() { int *p; int x = 37; cout<<"Line 1: x = "<<x<<endl; //Line 1 p = &x; //Line 2 cout<<"Line 3: *p = "<<*p <<", x = "<<x<<endl; //Line 3 *p = 58; //Line 4 cout<<"Line 5: *p = "<<*p <<", x = "<<x<<endl; //Line 5 cout<<"Line 6: Address of p = "<<&p<<endl; //Line 6 cout<<"Line 7: Value of p = "<<p<<endl; //Line 7

  16. cout<<"Line 8: Value of the memory location " <<"pointed to by *p = "<<*p<<endl; //Line 8 cout<<"Line 9: Address of x = "<<&x<<endl; //Line 9 cout<<"Line 10: Value of x = "<<x<<endl; //Line 10 return 0; } Sample Run Line 1: x = 37 Line 3: *p = 37, x = 37 Line 5: *p = 58, x = 58 Line 6: Address of p = 006BFDF4 Line 7: Value of p = 006BFDF0 Line 8: Value of the memory location pointed to by *p = 58 Line 9: Address of x = 006BFDF0 Line 10: Value of x = 58

  17. CLASSES, STRUCTS, AND POINTER VARIABLES • You can also declare pointers to other data types, such as classes and structs. struct studentType { char name[26]; double gpa; int sID; char grade; }; studentType student; studentType *studentPtr; studentPtr = &student;

  18. student.gpa = 3.9; (*studentPtr).gpa = 3.9; store 3.9 in the component gpa of the object student. • Since dot has a higher precedence than the dereferencing operator, parentheses are important. • C++ provides another operator, called the member access operator arrow, ->. • The syntax for accessing a class (struct) member using the operator -> is pointerVariableName->classMemberName • The following statements are equivalent. (*studentPtr).gpa = 3.9; studentPtr->gpa = 3.9;

  19. Example 14-3 class classExample { public: void setX(int a); void print() const; private: int x; }; void classExample::setX(int a) { x = a; } void classExample::print() const { cout<<"x = "<<x<<endl; }

  20. int main() { classExample *cExpPtr; //Line 1 classExample cExpObject; //Line 2 cExpPtr = &cExpObject; //Line 3 cExpPtr->setX(5); //Line 4 cExpPtr->print(); //Line 5 return 0; } Output x = 5

  21. INITIALIZING POINTER VARIABLES Because C++ does not automatically initialize variables, pointer variables must be initialized if you do not want to point to anything. Pointer variables are initialized using the constant value 0, called the null pointer. You can also use the constant NULL. p = NULL; p = 0;

  22. DYNAMIC VARIABLES • Variables that are created during program execution are called dynamic variables. • With the help of pointers, C++ creates dynamic variables. • C++ provides two operators, new and delete, to create and destroy dynamic variables, respectively. • When a program requires a new variable, the operator new is used; when a program no longer needs a dynamic variable, the operator delete is used. • In C++, new and delete are reserved words.

  23. The syntax to use the operator new is new dataType; //to allocate a single variable new dataType[intExp]; //to allocate an array of variables where intExp is any expression evaluating to a positive integer. • The operator new allocates memory (a variable) of the designated type and returns a pointer to it—that is, the address of this allocated memory. • The allocated memory is uninitialized.

  24. int *p; char *q; int x; • The statement p = &x; stores the address of x in p. No new memory is allocated. • The statement p = newint; creates a variable during execution somewhere in the memory, and stores the address of the allocated memory in p. • The allocated memory is accessed via pointer dereferencing, *p. • The statement q = newchar[16]; creates an array of 16 components of the type char and stores the base address in q.

  25. int *p; //p is a pointer of the type int char *name; //name is a pointer of the type char string *str; //str is a pointer of the type string p = newint; *p = 28; //stores 28 in the allocated memory name = newchar[5]; strcpy(name, "John"); //stores John in name str = new string; //allocates memory of the type string //and stores the address of the //allocated memory in str *str = "Sunny Day"; //stores the string "Sunny Day" in //memory pointed to by str

  26. The C++ operator delete is used to destroy dynamic variables. The syntax to use the operator delete has two forms: delete pointer; //to destroy a single dynamic variable delete [] pointer; //to destroy a dynamically created //array • The statements delete p; delete [] name; deallocate memory referenced by the pointers p and name.

  27. OPERATIONS ON POINTER VARIABLES • Assignment • Value of one pointer variable can be assigned to another pointer variable of the same type. • Relational operations • Two pointer variables of the same type can be compared for equality, and so on. • Some limited arithmetic operations. • Integer values can be added and subtracted from a pointer variable. • Value of one pointer variable can be subtracted from another pointer variable.

  28. int *p, *q; The statement p = q; copies the value of q into p. The expression p == q evaluates to true if both p and q have the same value. The expression p != q evaluates to true, if both p and q point to different memory locations.

  29. Arithmetic operations, that are allowed, differ from the arithmetic operations on numbers. int *p; double *q; char *chPtr; studentType *stdPtr; //studentType data type is //as defined before • The memory allocated for an int variable is 4 bytes, a double variable is 8 bytes, and a char variable is 1 byte. The memory allocated for a variable of the type studentType is 39 bytes. • The statement p++; or p = p+1; increments the value of p by 4 bytes.

  30. The statements q++; chPtr++; increment the value of q by 8 bytes and the value of chPtr by 1 byte • The statement stdPtr++; increments the value of stdPtr by 39 bytes. • The statement p = p + 2; increments the value of p by 8 bytes.

  31. When an integer is added to a pointer variable, the value of the pointer variable is incremented by the integer times the size of the memory that the pointer is pointing to. • When an integer is subtracted from a pointer variable, the value of the pointer variable is decremented by the integer times the size of the memory to which the pointer is pointing.

  32. DYNAMIC ARRAYS • An array created during the execution of a program is called a dynamic array. • To create a dynamic array, we use the second form of the new operator. • The statement int *p; declares p to be a pointer variable of the type int. • The statement p = newint[10]; allocates 10 contiguous memory locations, each of the type int, and stores the address of the first memory location into p.

  33. The statement *p = 25; stores 25 into the first memory location. p++; *p = 35; stores 35 into the second memory location. • C++ allows us to use array notation to access these memory locations. p[0] = 25; p[1] = 35; for(j = 0; j < 10; j++) p[j] = 0;

  34. int list[10]; • list is a pointer variable. • We always want list to point to the first array component. • Any attempt to use increment or decrement operation on list will result in compile time error. • If p is a pointer variable of the typeint, then the statement p = list; copies the value of list into p. We are allowed to perform increment and decrement operations on p. • An array name is a constant pointer.

  35. Example 14-4 • int *intList; //Line 1 • int arraySize; //Line 2 • cout<<"Enter array size: "; //Line 3 • cin>>arraySize; //Line 4 • cout<<endl; //Line 5 • intList = newint[arraySize]; //Line 6 • The statement at Line 1 declares intList to be a pointer of the type int • The statement at Line 2 declares arraySize to be an int variable. • The statement at Line 3 prompts the user to enter the size of the array. • The statement at Line 4 inputs the array size into the variable arraySize. • The statement at Line 6 creates an array of the size specified by arraySize, and the base address of the array is stored in intList. • From this point on, you can treat intList just like any other array. For example, you can use the array notation to process the elements of intList and pass intList as a parameter to the function.

  36. Functions and Pointers • A pointer variable can be passed as a parameter to a function either by value or by reference. • In C++, to make a pointer a reference parameter in a function heading, * appears before the & between the data type name and the identifier. void example(int* &p, double *q) { . . . } • Both p and q are pointers. The parameter p is a reference parameter; the parameter q is a value parameter.

  37. Pointers and Function Return Value • In C++, a function can return a value of the type pointer. • The return type of the function int* testExp(...) { . . . } is a pointer of the type int.

  38. SHALLOW VERSUS DEEP COPY AND POINTERS int *p; p = newint; • The first statement declares p to be a pointer variable of the type int. • The second statement allocates memory of the type int, and the address of the allocated memory is stored in.

  39. *p = 87; int *first; int *second; first = newint[10];

  40. second = first; //Line ***

  41. delete [] second; In a shallow copy, two or more pointers of the same type point to the same memory; that is, they point to the same data.

  42. second = newint[10]; for(int j = 0; j < 10; j++) second[j] = first[j]; • In a deep copy, two or more pointers have their own data.

  43. CLASSES AND POINTERS: SOME PECULIARITIES class pointerDataClass { public: ... private: int x; int lenP; int *p; }; pointerDataClass objectOne; pointerDataClass objectTwo;

  44. The Destructor • The object objectOne has a pointer data member p. • Suppose that during program execution the pointer p creates a dynamic array. • When objectOne goes out of scope, all data members of objectOne are destroyed. • However, p created a dynamic array, and dynamic memory must be deallocated using the operator delete. • If the pointer p does not use the delete operator to deallocate the dynamic array, the memory space of the dynamic array would stay marked as allocated, even though no one can access it. • How do we ensure that when p is destroyed, the dynamic memory created by p is also destroyed?

  45. If a class has a destructor, the destructor automatically executes whenever a class object goes out of scope. • We can put the necessary code in the destructor to ensure that when objectOne goes out of scope, the memory created by the pointer p is deallocated. pointerDataClass::~pointerDataClass() { delete [] p; } class pointerDataClass { public: ~pointerDataClass(); ... private: int x; int lenP; int *p; };

  46. The Assignment Operator

  47. objectTwo = objectOne; • If objectTwo.p deallocates the memory space to which it points, objectOne.p would become invalid.

  48. To avoid this shallow copying of data for classes with a pointer data member, C++ allows the programmer to extend the definition of the assignment operator. • This process is called overloading the assignment operator. • Chapter 15 explains how to accomplish this task by using operator overloading. • Once the assignment operator is properly overloaded, both the objects objectOne and objectTwo have their own data, as shown in Figure 14-19.

  49. The Copy Constructor • Consider the following statement: pointerDataClass objectThree(objectOne); • The object objectThree is being declared and is also being initialized by using the value of objectOne. • This initialization is called the default member-wise initialization. • The default member-wise initialization is due to the constructor, called the copy constructor (provided by the compiler.) • This default initialization would lead to a shallow copying of the data.

  50. void destroyList(pointerDataClass paramObject); destroyList(objectOne);

More Related