1 / 36

Pointers - PowerPoint PPT Presentation

  • Uploaded on

Pointers. ACS 169. Pointers. Pointer a data type stores a memory address points to whatever the memory location contains A pointer is a variable that can store a memory address. The type of item pointed to by a pointer variable is the target type. Examples.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Pointers' - niyati

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript


ACS 169


  • Pointer

    • a data type

    • stores a memory address

    • points to whatever the memory location contains

  • A pointer is a variable that can store a memory address.

    • The type of item pointed to by a pointer variable is the target type.


  • Declaring Pointerstype *name;

  • Pointer Declarations:

    • int * ptr;

    • char *cptr;

    • double *dptr;


  • int * ptr;int v = 5;ptr = & v ;

  • The & operator is called the address operator

  • either of the following assignments will store the value of 10 in the variable v:

    v = 10 ;

    *ptr = 10 ;

Pointers dereferencing cont
Pointers: Dereferencing cont.

  • So far the asterisk is used in two ways:

  • 1. int *ptr;

  • 2. *ptr = 10 ;

  • the first declares the variable ptr as a pointer of type integer but it does not make it point to any memory address.

  • the second assigns the value 10 to the memory location pointed at by ptr. dereferencing


  • Explain each line in the following code:

    int *ptr ;

    int number = 42 ;

    ptr = &number ;

    *ptr = 0 ;

    cout << *ptr <<endl ;

    cout << number << endl;

Pointers cont
Pointers cont.

  • Explain the following code:

    int *p1 ;

    int *p2;

    p1 = & count ;

    int *p2;

    *p2 = *p1;

    p2 = p1 ;

Dynamic variables
Dynamic Variables

  • Dynamic Variables (DVs) are different than normal variables in two aspects:

  • DVs are not declared (have no identifiers, …no variable names)

  • DVs are created during execution phase of a program and not during compilation, the keyword newis used for this purpose.

Dynamic variables cont
Dynamic Variables cont.


int * ptr;

ptr=new int;

  • this statement creates a DV of type integer and uses ptr to point to it. There is no identifier (name) for the variable pointed at by ptr

Dynamic variables cont1
Dynamic Variables cont.

  • The creation of new DVs is called memory allocation and the allocated memory is called dynamic memory

    ptr = new int;

  • Makes ptr point to a newly allocated integer variable from dynamic memory.

Dynamic variables cont2
Dynamic Variables cont.

int *ptr ;

ptr = new int ;

*ptr = 33;

Dynamic variables cont3
Dynamic Variables cont.

int *n;

n = new int(17);

MyType *p;

p = new MyType;


p = new MyType(32.0, 17);

The new operator objects
The new operator & Objects

  • throttle *t_ptr;t_ptr = new throttle(50) ;

  • calls the throttle constructor with an integer argument

Dynamic arrays
Dynamic Arrays.

  • To declare a dynamic array use:

    int *ptr ;

    ptr = new int[10] ;

    the new operator allocates a dynamic array of 10 integers and makes ptr point to its first element.

Dynamic arrays cont
Dynamic Arrays cont.

  • the statement:

    ptr[5] = 33;

    will store the value 33 as the 6th element in the array pointed to by ptr


  • When new allocates a dynamic variable or dynamic array, the memory comes from a location called the program’s heap (also called the free store).

  • bad_allocexception is thrown when new attempts to allocate memory and fails.


  • Determine what the following code will do

    int array_size ;

    int *numbers;

    cout << “how many numbers do you have?”;

    cin >> array_size ;

    numbers = new int[array_size] ;


  • The operator new is used to dynamically allocate an array of size array_size that the user enters interactively.


  • Who should initialize the components of a dynamically allocated array whose components are of a class data type ?

  • Ans: the default constructor will initialize all components of the array

Delete operator
Delete Operator

  • It is an efficient practice to release any heap memory that is no longer needed.

  • The delete operator is used in C++ to release memory to the heap that is no longer needed.

Delete operation
Delete operation

  • Examples: int *ptr; ptr = new int; … delete ptr ; ptr = NULL;

    int *p; p = new int[30]; … delete [] p;

Pointers as value parameters
Pointers as value parameters

int *main_ptr;

main_ptr = new int;


void make_it_42(int* my_ptr) ;


*my_ptr = 42;


Pointers as value parameters1
Pointers as value parameters

  • The following function prototype:

    void make_it_42(int* my_ptr) ;

    the int* indicates that the parameter is of data type integer pointer.

    the parameter is a value parameter because of the absence of the & operator.

Array parameters
Array Parameters

void make_it_all_42( double * num, size_t n);


double *numbers;

num = new double[10];

make_it_all_42(num, 10);


void make_it_all_42(double * num, int n)


for(int i=0; i<n; i++) num[i] = 42;


void make_it_all_42(double * num, int n)


for(size_t i=0; i<n; i++)

num[i] = 42;


void make_it_all_42(double num[], int n)


for(size_t i=0; i<n; i++) num[i] = 42;


Array parameters cont
Array parameters cont.

  • A parameter that is a pointer or array may include the const keyword. No changes to the actual parameter or the array are possible in this case

    bool is_42(const int* my_ptr);

    double average(const double data[], … )

Pointers reference parameters
Pointers Reference Parameters

  • Sometimes a function needs to change a pointer parameter so that the pointer points to a new location.

  • Example:

    void alloc_doubles(double*& ptr, int & n);

Pointer reference parameters
Pointer Reference Parameters

void alloc_doubles(double*& ptr, int & n);

double *numbers;

int array_size;

alloc_doubles(numbers, array_size);

void alloc_doubles(double*& ptr, int & n)


cin>> n;

ptr = new double[n];


Pointer arithmetic
Pointer Arithmetic

  • The only legal arithmetic operators on pointers are adding or subtracting an integer, or subtracting one pointer from another.

Pointer arithmetic1
Pointer Arithmetic

  • In C++, pointer arithmetic is automatically done in units of the pointer's underlying base type.

  • Adding 1 to a pointer to an array element gives a pointer to the next element - regardless of whether we have an array of ints, an array of doubles, or an array of any other type.

Pointer arithmetic2
Pointer Arithmetic

int ar[10];

ar + i is a pionter to the ith element beyond ar

&ar[i] is equivalent to ar + i

ar[i] is equivalent to *(ar + i)

What is the output
What is the output?

int main()


int * array;

array = new int[10];

*array = 33;

*(array + 3) = 14;


return 0;