Data, memory. Pointers and Dynamic Variables. Example. Pointers Variables (or Pointers) Fall 2018, CS2

Size: px

Start display at page:

Download "Data, memory. Pointers and Dynamic Variables. Example. Pointers Variables (or Pointers) Fall 2018, CS2"

Sharleen May
5 years ago
Views:

1 Data, memor Pointers and Dnamic Variables Fall 2018, CS2 memor address: ever bte is identified b a numeric address in the memor. a data value requiring multiple btes are stored consecutivel in memor cells and identified b the address of the first bte In program we can: find amount of memor (num. of btes) assigned to a variable or a data tpe: sizeof(int), sizeof find the address of a variable: & 1 2 Eample Pointers Variables (or Pointers) int, ; Pointer variables: a variable that stores memor address (of another variable) is used to tell where a variable is stored in memor int takes 4 btes address of is the address of its first bte Pointers "point" to a variable Memor addresses can be used to access variables Arra variable actuall stores address of the first element in arra int a[10]; cout <<a<<endl; cout <<&(a[0])<<endl; When a variable is used as a call-b-reference argument, its address is passed 3 4

2 Declaring Pointers Pointer variables must be declared to have a pointer tpe E: To declare a pointer variable p that can "point" to a variable of tpe double: double *p; The asterisk identifies p as a pointer variable Declaring pointer variables DataTpe * pointervariable; //declare a pointervariable that can be used to point to DataTpe variable int * p; char *cptr; DaOfYear * pdate; //pdate is a pointer pointing to DaOfYear obj double *q; //no space between * and variable name Like other variables, before initialization, p and cptr might contain some arbitrar value So, important to initialize: int *p=null; // assign NULL constant to p, a pointer variable to indicate // that p does not point to an valid data // internall, NULL is value 0. Common pitfall: int *, *; //, are both pointers that point to int int *, ; // is pointer, but is int //* onl applies to the variable that follows it, ; not 6 pointer to different tpes address of Operator DataTpe * pointervariable; //declare a pointervariable that can be used to point to DataTpe variable int * p=null; char *cptr=null; DaOfYear * pdate=null; //pdate is a pointer pointing to DaOfYear obj double *q=null; //no space between * and variable name Pointers to different tpes have same size, sizeof(int *)==sizeof(double *) //8 wh differentiate them? int and double, char, takes different number of btes, and interpret data differentl &variable: ield the address of a variable can then be assigned to a pointer variable int v1; int * ; = &v1; // assign address of v1 to // is now a pointer (pointing) to v1 int a[10]; assert (a==&(a[0])); //arra variable itself stores address 7

Eample Tpical laout of a program in memor address name int, ; int *, *; local variables address of : 140724463361388

07ffcbf8f5a88 address of 07ffcbf8f5a80 address of 07ffcbf8f5a78 Global variables static variables 9 10.

3 Eample Tpical laout of a program in memor address name int, ; int *, *; local variables address of : address of : address of : address of : address of 07ffcbf8f5a8c address of 07ffcbf8f5a88 address of 07ffcbf8f5a80 address of 07ffcbf8f5a78 Global variables static variables int a() b(); c(); return 0; Stack and StackFrame Eample int, ; int *, *; int b() return 0; int c() return 0; int main() a(); return 0; =-42; =; 12

4 Eample dereferencing Operator -42 int, ; int *, *; =-42; =; =&; =&; *pointervariable: the variable that pointervariable points to Here the * is dereferencing operator, pointervariable is said to be dereferenced int v1; int *; //this * means is a pointer = &v1; // assign address of v1 to cout << *; //displa the int that points to, i.e, v1 Pitfall/reminder: the contet is important! * used between tpe and name vs. * before a pointer variable 13 Eample int, ; int *, *; -42 =-42; =; =&; =&; Fundamental pointer operations & address-of a variable. Its operand is a variable. eample: int *p; int a=10; p=&a; * variable that a pointer is pointed to. Its operand is a pointer. eample: *p=5; the are used to move back and forth between variables and pointers to those variables. 17 *=17; int *p; *p=5; //the variable pointed to b aptr has to be valid //* is another name of for int *p=null; <=> int *p; p=null; 15 16

5 eample int, ; 17 int *, *; =-42; =; =&; =&; *=17; /* another name of for */ eample int, ; 17 int *, *; =-42; =; =&; =&; *=17; /* another name of for */ 17 =; /* pointer assignment, now two pointers point to the same location*/ *=*; /*value assignment*/ //think of * as another name of the variable points to Usage of pointers Allow one to refer to a large data structure in a compact wa. Each pointer (or memor address) tpicall fits in four btes of memor! Arra: static or dnamic arras Different parts of a program can share same data: passing parameters b reference (passing address between different functions), or b pointers One can reserve new memor in a running program: dnamic memor allocation Build complicated data structures b linking different data items Passing parameters b reference using pointers Suppose we want to set (defined in main() function) to zero, compare the following code: /*pass b value*/ void SetToZero1 (int var) var=0; /*pass b pointer*/ void SetToZero2(int *ip) *ip=0; int main() int =; SetToZero1() SetToZero2 (&); 19 20

6 for main() in our computer s memor int main () =; SetToZero(); int main () =; SetToZero(); var for SetToZero1() in our computer s void SetToZero (int var) var=0; var void SetToZero (int var) var=0; memor of main() int main () =; SetToZero2(&); 0 int main () =; SetToZero(&); ip of SetToZero2 void SetToZero2(int *ip) *ip=0; ip void SetToZero(int *ip) *ip=0; 23 24

7 Passing parameters void SetToZero1 (int var) var=0; SetToZero(); /* has no effect on */ void SetToZero2(int *ip) *ip=0; SetToZero2(&); void SetToZero3 (int & var) var = 0; SetToZero3 (); main SetToZero(); SetToZero(&); SetToZero3(); SetToZero1 var=; var=0; SetToZero2 ip=&;//ip points to *ip=0; SetToZero3 var refers to var=0; //=0 25 Eample write a program to solve quadratic equation: a^2 + b + c = 0; program structure: input phase: accept values of coefficients from users; void GetCoefficients(double *pa, double *pb, double *pc); computation phase: solve the equation based on those coefficients; void SolveQuadratic(double a, double b, double c, double *, double *); output phase: displa the roots of the equation on the screen void DisplaRoots(double 1, double 2); 26 Global Variables Variable Scopes and Lifetimes - a bigger picture about memor used b a program Variables declared outside an function are global variables the have global scope, i.e., the can be accessed b the name from all parts of a program - unless there is an eclipse! the comes into being when program starts, and disappears when program ends ==> static lifetime We discourage the usage of global variables too man cooks in the kitchen: everone can modif it 27

Local Variables Variables declared in a function are local variables the have local scope : the can be accessed using the name from the function/block The are tpicall created when the function is

8 Local Variables Variables declared in a function are local variables the have local scope : the can be accessed using the name from the function/block The are tpicall created when the function is called, and destroed when the function call ends ==> automatic lifetime Local variable with static lifetime? void some_func() static int counter=0; //created at program starts, //destroed when program ends counter++; cout <<"called " << counter<<" times\n ; // Dnamic Variables Programmer/Code can create variables and then destro them using operators new and delete e.g., such variables are dnamic variables, their lifetime is dnamic (decided at running time, based upon running time condition). The have no name. int *; //declare a pointer variable = new int; //create a int variable, save its address in This variable can onl be referred b address (as it has no name), * * can be used an place an integer variable can cin >> *; * = * + 7; Displa 9.2 Displa

9 Caution! Pointer Assignments Basic Memor Management Some care is required making assignments to pointer variables = p3; // changes the location that "points" to * = *p3; // changes the value at the location that // "points" to An area of memor called the freestore/heap is reserved for dnamic variables New dnamic variables use memor in the freestore If all of the freestore is used, calls to new will fail Unneeded memor can be reccled When variables are no longer needed, the need to be deleted and the memor the used is returned to the freestore delete Operator When dnamic variables are no longer needed, delete them to reccle memor to freestore e.g., delete p; memor used b the variable that p pointed to is back in freestore. p still stores that address. *p=10; // Disaster!!! p = NULL; //value of p is now NULL Dangling Pointers Using delete on a pointer variable destros the dnamic variable pointed to If another pointer variable was pointing to the dnamic variable, that variable is also undefined Undefined pointer variables are called dangling pointers Dereferencing a dangling pointer (*p) is usuall disasterous

10 Tpe Definitions Defining Pointer Tpes A name can be assigned to a tpe definition, then used to declare variables The keword tpedef is used to define new tpe names Snta: tpedef Known_Tpe_Definition New_Tpe_Name; Known_Tpe_Definition can be an tpe To avoid mistakes using pointers, define a pointer tpe name Eample: tpedef int* IntPtr; Defines a new tpe, IntPtr, for pointer variables containing pointers to int variables IntPtr p; is equivalent to int *p; Multiple Declarations Again Pointer Reference Parameters Using our new pointer tpe defined as tpedef int* IntPtr; Then, we can prevent this error in pointer declaration: int *P1, P2;//Onl P1 is a pointer variable with IntPtr P1, P2; // P1 and P2 are pointer variables A second advantage in using tpedef to define a pointer tpe is seen in parameter lists Eample: void sample_function(intptr& pointer_var); is less confusing than void sample_function( int*& pointer_var);

What have we learned about when we learned about function parameters? 1-1

What have we learned about when we learned about function parameters? 1-1 What have we learned about when we learned about function parameters? Call-by-Value also known as scalars (eg. int, double, char,