# Pointers and References

Size: px
Start display at page:

Transcription

1 Steven Zeil October 2, 2013 Contents 1 References 2 2 Pointers 8 21 Working with Pointers Memory and C++ Programs Allocating Data Pointers Can Be Dangerous 17 3 The Secret World of Pointers Pointers and Arrays Pointer and Strings Pointers and Member Functions 23 1

3 Initializing References z zk 10 When reference variables are declared, they must be immediately initialized to the location of some existing data value, eg, double& zk = z [ k ] ; / / zk get address of z [ k ] One initialized, a reference cannot be reset to point to a different location Accessing data Via References CS250 3

4 z zk One initialized, we can use the reference much like any ordinary variable: double& zk = z [ k ] ; / / zk get address of z [ k ] cout << zk ; / / accesses data stored / / at that location Assignment and References Subsequent assignments to a reference variable will store new values at that location, but will not change the location double& zk = z [ k ] ; / / zk get address of z [ k ] zk = 1 0 ; / / changes the value of z [ k ] ++k ; zk = 2 0 ; / / changes the value of z [ k 1] Example: working with indirection Question: What would the output of the following code be? int a = 1 ; int b = a ; cout << a << " " << b << endl ; a = 2 ; cout << a << " " << b << endl ; b = 3 ; cout << a << " " << b << endl ; CS250 4

5 Answer: a and b are distinct variables A change to one has no effect on the other Example: working with indirection (cont) Let s make a one-character change Question: What would the output of the following code be? int a = 1 ; int& b = a ; cout << a << " " << b << endl ; a = 2 ; cout << a << " " << b << endl ; b = 3 ; cout << a << " " << b << endl ; CS250 5

6 Answer: a and b are synonyms for the same data value A change to one can be seen via the other References and Loops Once initialized, a reference cannot be reset to a different location However, if we declare a reference within a loop body: for ( int i = 0 ; i < 100; ++ i ) { int k = longandcomplicatedcalculation ( i ) ; double& zk = z [ k ] ; dosomethingwith ( zk ) ; } Then each time around the loop we are initializing a different reference variable Variables that are declared inside a { } are destroyed when we reach the closing } So, each time around the loop, zk refers to a different element of the array The above example suggests one reason why we may use references to avoid repeating long and complicated calculations to select array elements or struct members Const References When we modify a reference type by pre-pending const : We are allowed to look at the data value whose address is stored in the reference But we cannot alter the data value via that reference Money price (24, 9 5 ) ; Money& saleprice = price ; const Money& oldprice = price ; price d o l l a r s = 25; / / OK saleprice d o l l a r s = 26; / / OK oldprice cents = 0 ; / / i l l e g a l, cannot change value Note that both of the legal assignments would affect the values seen in all three variables CS250 6

7 References and Functions You ve seen lots of functions using reference parameters void foo (Money& m, const Time& t ) ; We ve explained in the past that this was pass by reference, a special parameter passing mechanism In fact, as far as the compiler is concerned, there is no special parameter passing mechanism This is still pass by copy But the type of data being copied and passed are references All the special behavior associated with reference parameters stems from the normal properties of references * Passes addresses instead of actual data * Allows alteration of data back in the caller * Unless the reference type is marked const, in which case we can look but not touch References and Functions (returns) References are also sometimes used as return types const Money& getamountbid ( Bid& b) { return b amountbid ; } cout << getamountbid (mybid ) d o l l a r s ; Slight improvement in efficiency the Money value does not need to be copied References and Functions (returns) cont Money& getamountbid ( Bid& b) { return b amountbid ; } getamountbid (mybid ) d o l l a r s = 0 ; CS250 7

8 2 Pointers Pointers Pointers, like references, store the location or address of data Pointers relax many of the restrictions on references Pointers need not be initialized when declared (a bad idea) When initialized, they need not hold an address of existing data * can be null instead After initialization, they can be reassigned to refer to a different data element But pointers lose some of the convenience of references: Require special syntax to access the data referred to by a pointer 21 Working with Pointers Declaring Pointer Variables A pointer declared like this double *p ; contains, essentially, random bits To be useful, it must be initialized double *p = or, later, re-assigned p = Initializing Pointer Variables Where do new pointer values come from? Pointers can be given the addresses stored in other pointers: int * q = int * p = q ; But that doesn t really answer the question It just defers it CS250 8

9 Pointers can be assigned the address of an existing data value via the & operator: int a = 23; int *p = &a ; But this is rare, dangerous, and generally frowned upon Pointers can be given the address of newly allocated data: int *p = new int ; int *pa = new int [ ] ; Pointers can be set to null, a special value indicating that it does not point to any real data There are multiple ways to do this: 0 is a null pointer int *p = 0 ; * That s not zero It s a null pointer NULL is a special symbol declared in <cstdlib> #include <cstdlib > int * p = NULL; Coming soon, courtesy of the new C++11 standard int *p = nullptr ; NULL is actually a bit of a problem Not only do you have to include a special header to get it, but there are some rare circumstances where passing it to functions that take a pointer as parameter will not compile properly Hence the new standard introduced a better-behaved universal null pointer constant This won t be available, however, until compilers take the C++11 features out of their beta status Dereferencing a Pointer Accessing data whose address is stored in a pointer is called dereferencing the pointer The unary operator * provides access to the data whose location is stored in a pointer: Money *p = new Money(100, 2 5 ) ; Money m = *p ; / / * gets the whole data element *p = Money( 0, 1 5 ) ; / / and we can store there CS250 9

10 Dereferencing and Structs The operator -> provides access to struct members via a pointer: Money *p = new Money(100, 2 5 ) ; int totalcents = 100*p >d o l l a r s + p >cents ; p >d o l l a r s = 0 ; These two statements are equivalent: p >d o l l a r s = 0 ; ( *p ) d o l l a r s = 0 ; Assignment and Pointers Subsequent assignments to a pointer variable will change the location it points to double* zk = &(z [ k ] ) ; / / zk get address of z [ k ] * zk = 1 0 ; / / changes the value of z [ k ] zk = &(z [ k + 1 ] ) ; zk = 2 0 ; / / changes the value of z [ k+1] Example: working with pointers Question: What would the output of the following code be? int a = 1 ; int b = 2 ; int * pa = &a ; int * pb = &b ; cout << a << " " << *pa << " " << b << endl ; a = 3 ; cout << a << " " << *pa << " " << b << endl ; *pb = 4 ; cout << a << " " << *pa << " " << b << endl ; pa = pb ; cout << a << " " << *pa << " " << b << endl ; CS250 10

11 Answer: Const Pointers When we modify a pointer type by pre-pending const : We are allowed to look at the data value whose address is stored in the reference But we cannot alter the data value via that reference Money price (24, 9 5 ) ; Money* saleprice = &price ; const Money* oldprice = s aleprice ; price d o l l a r s = 25; / / OK saleprice >d o l l a r s = 26; / / OK oldprice >cents = 0 ; / / i l l e g a l, cannot change value Same as the affect of const on references 211 Memory and C++ Programs Where is data Stored? The memory of a running C++ program is divided into three main areas: The static area holds variables that have a single fixed address for the lifetime of the execution Variables declared outside of any enclosing { } or marked as static The runtime stack (aka activation stack or automatic storage) has a block of storage for each function that has been called but from which we have not yet returned All copy parameters and local variables for the function are stored in that block The block is created when we enter the function body and destroyed when we leave the body The heap is a programmer-controlled scratch pad where we can store variables But the programmer has the responsibility for managing data stored there CS250 11

12 How Functions Work int foo ( int a, int b) { return a+b 1; } would compile into a block of code equivalent to stack [ 1 ] = stack [ 3 ] + stack [ 2 ] 1 ; jump to address in stack [ 0 ] The Runtime Stack the stack is the runtime stack (aka the activation stack) used to track function calls at the system level, stack[0] is the top value on the stack, stack[1] the value just under that one, and so on An Example of Function Activation Suppose that we were executing this code, and had just come to the call to resolveauction within main #include " time h" void resolveauction ( Item item ) { int h = item auctionendsat gettime ( ) ; } int main ( int argc, char ** argv ) { resolveauction ( item ) ; } CS250 12

13 The runtime stack (aka, the activation stack) would, at this point in time, contain a single activation record for the main function, as that is the only function currently executing: When main calls resolveauction, a new record is added to the stack with space for all the data required for this new function call CS250 13

14 When resolveauction calls gettime, another new record is added to the stack with space for all the data required for that new function call But once gethours returns (to resolveauction), that activation record is removed from the stack resolveauction is once again the active function CS250 14

15 And when resolveauction returns, its record is likewise removed from the stack 212 Allocating Data Example of Overall Memory layout CS250 15

16 Activation Stack Heap main() argc: 3 argv: Boston itinerary() from: Boston to: NY NY Wash DC hubs: Boston NY "Boston" "airlineexe" "NY" Static Area Allocating Data on the Heap We allocate data with new and remove it with delete: int *p = new int ; int *pa = new int [ ] ; delete p ; delete [ ] pa ; CS250 16

17 Note the slightly different forms for arrays versus single instances Dynamic Allocation Programmers often distinguish between dynamic and static activities: Something is dynamic if it happens at run-time, under control of the program Something is static if it happens at compile-time and/or is controlled by the compiler int *p = new int ; int *pa = new int [ ] ; Allocation of data via new is called dynamic allocation of data Dynamically allocated memory is controlled through the two operators new and delete The new operator allocates sufficient memory to store one or more objects of the specified type The type of the object to be allocated follows the new operator Memory is allocated from the heap The delete operator returns the memory allocated to an object back to the memory pool to be reused Summary: Pointers versus References 22 Pointers Can Be Dangerous References Pointers Type Declaration & * Initialization must be initialized optional points to existing data may be null Dereferencing automatic *, -> Management automatic new, delete Dangerous? minimal very Because pointers provide access a memory location and because data and executable code exist in memory together, misuses of pointers can lead to both bizarre effects and very subtle errors CS250 17

18 Potential Problems with Pointers uninitialized pointers, memory leaks and dangling pointers Uninitialized pointers Uninitialized pointer pose a significant thread the value stored in an uninitialized pointer could be randomly pointing anywhere in memory Storing a value using an uninitialized pointer has the potential to overwrite anything in your program, including your program itself Your best defense: Never write a declaration like Money* p ; Always give your pointers an initial value Money* p = 0 ; Null if you can t make it point to a real data value Memory Leaks A memory leak occurs when all pointers to a value allocated on the heap has been lost, eg, int i s q r t ( int i ) { int * work = new int ; *work = i ; while ( ( * work ) * ( * work ) > i ) ( * work ) ; return *work ; } When we return from this function the local variable work is lost CS250 18

19 But that has the only copy of the address of the int that we allocated on the heap Each call to this function will leak a bit of memory Over time, memory leaks can cause programs to slow down and, eventually, crash Worse, a leaky program may come to take up so much of a systems memory that it interferes with the operation of other programs on the same system Dangling Pointers Dangling pointers refer to a pointer which was pointing at an object that has been deleted int * p = new int ; int * q = p ; delete p ; The pointer q still has the address of the object even though the memory for that object has been returned to the system If the memory allocated to the deleted object is re-used for another purpose, The value visible via q may appear to spontaneously change Storing a value via q may corrupt that other data 3 The Secret World of Pointers 31 Pointers and Arrays What s in a Name? (of an array) int a [ ] ; double b[ ] ; You know what expressions like a[i] and b[2] do But what about just a or b? CS250 19

20 Arrays are Pointers int a [ ] ; double b[ ] ; Arrays are really pointers a has type * int b has type * double They point to the first ([0]) element You may have observed examples of passing arrays to functions as parameters They are usually passed as pointers That s possible because of the fact that arrays really are pointers Pointer Arithmetic You can add integers to pointers #include <iostream> using namespace std; int main() { int *i = new int; double *d = new double; cout << "i " << i << " i = i + 1; ++d; cout << "i " << i << " return 0; } d " << d << endl; d " << d << endl; > g++ pointerarith cpp > / a out i 0x1eea010 d 0x1eea030 i 0x1eea014 d 0x1eea038 > Actually adds to the address the number of bytes required to store one data value of the type pointed to CS250 20

21 Pointer Arithmetic 2 You can subtract pointers from one another #include <iostream> using namespace std; int main() { int array[5]; int* p = &(array[0]); int* q = &(array[3]); cout << "p " << p; cout << " q " << q; cout << " q-p " << (q-p); cout << endl; } > g++ pointerarith2 cpp > / a out p 0 x7fff2065c380 q 0 x7fff2065c38c q p 3 > Computes how many element-sized blocks away from wach other the two addresses are OK, Why do Pointer Arithmetic? Pointer arithmetic is actually illegal and pretty much useless except when the addresses are all within a single array double b[ ] ; b is a pointer to the start of the array b[i] is simply a convenient shorthand for * (b+i) CS250 21

22 Pointers, Arrays, and Functions This is why, when arrays are passed to functions, they are generally passed as pointers: double sumoverarray ( double* a, int n) { double s = 0 0 ; for ( int i = 0 ; i < n ; ++ i ) s += a [ i ] ; return s ; } We ll have more on this shortly when we look at dynamically allocated arrays 32 Pointer and Strings Not all strings are created equal In C++ s parent language, C, there is no std::string Strings were stored in character arrays End of a string was indicated by a byte containing the ASCII character NUL (value 0) Less than satisfactory NUL is actually a useful character in some contexts Many string operations were needlessly slow C++ retains the C string operations for backwards compatibility String Literals The most common place where strings and character arrays meet is in string literals "abc" does not have type std::string Its data type is actually const char* And it actually takes up 4 characters, not 3 The std::string type provides a constructor s t r i n g ( const char * chararray ) ; for building new strings from character arrays CS250 22

23 main The main function in C++ programs has the prototype int main ( int argc, char ** argv ) argc is the number of command line parameters argv holds the command line parameters Question: Why are there two asterisks in char**? The first * indicates that each parameter is a C-style character array (passed, as is common for arrays, as a pointer) The second * indicates that this is an array of those character arrays (again, passed as a pointer), because there can be multiple command line parameters 33 Pointers and Member Functions Hide the Parameter Remember that when we convert standalone functions to member functions, one parameter becomes implicit: struct Money { } ; Money add (Money l e f t, Money r i g h t ) ; becomes struct Money { Money add (Money r i g h t ) ; } ; Revealing the Hidden Parameter That parameter really does exist Its name is this Its data type, for any struct S, is S* struct Money { smvdots Money add ( / * Money* this, * / Money r i g h t ) ; } ; CS250 23

24 Using this Sometimes we need to make explicit reference to the implicit parameter Suppose that we had Money Money : : add (Money r i g h t ) { Money r e s u l t ; r e s u l t d o l l a r s = d o l l a r s + r i g h t d o l l a r s ; r e s u l t cents = cents + r i g h t cents ; return r e s u l t ; } and wanted to add some debugging output Explicit this Money Money : : add (Money r i g h t ) { cerr << " Entering Money : : add, adding " << * this << " to " << r i g h t << endl ; Money r e s u l t ; r e s u l t d o l l a r s = d o l l a r s + r i g h t d o l l a r s ; r e s u l t cents = cents + r i g h t cents ; return r e s u l t ; } There s really no other way to pass the whole left value to another function or operator The need to explicitly refer to this is unusual, but not all that rare CS250 24

### CA31-1K DIS. Pointers. TA: You Lu

CA31-1K DIS Pointers TA: You Lu Pointers Recall that while we think of variables by their names like: int numbers; Computer likes to think of variables by their memory address: 0012FED4 A pointer is a

### PIC 10A Pointers, Arrays, and Dynamic Memory Allocation. Ernest Ryu UCLA Mathematics

PIC 10A Pointers, Arrays, and Dynamic Memory Allocation Ernest Ryu UCLA Mathematics Pointers A variable is stored somewhere in memory. The address-of operator & returns the memory address of the variable.

### C++ for Java Programmers

Basics all Finished! Everything we have covered so far: Lecture 5 Operators Variables Arrays Null Terminated Strings Structs Functions 1 2 45 mins of pure fun Introduction Today: Pointers Pointers Even

### CSCI-1200 Data Structures Fall 2017 Lecture 5 Pointers, Arrays, & Pointer Arithmetic

CSCI-1200 Data Structures Fall 2017 Lecture 5 Pointers, Arrays, & Pointer Arithmetic Review from Letctures 3 & 4 C++ class syntax, designing classes, classes vs. structs; Passing comparison functions to

### INITIALISING POINTER VARIABLES; DYNAMIC VARIABLES; OPERATIONS ON POINTERS

INITIALISING POINTER VARIABLES; DYNAMIC VARIABLES; OPERATIONS ON POINTERS Pages 792 to 800 Anna Rakitianskaia, University of Pretoria INITIALISING POINTER VARIABLES Pointer variables are declared by putting

### CE221 Programming in C++ Part 2 References and Pointers, Arrays and Strings

CE221 Programming in C++ Part 2 References and Pointers, Arrays and Strings 19/10/2017 CE221 Part 2 1 Variables and References 1 In Java a variable of primitive type is associated with a memory location

### QUIZ. What is wrong with this code that uses default arguments?

QUIZ What is wrong with this code that uses default arguments? Solution The value of the default argument should be placed in either declaration or definition, not both! QUIZ What is wrong with this code

### 12. Pointers Address-of operator (&)

12. Pointers In earlier chapters, variables have been explained as locations in the computer's memory which can be accessed by their identifer (their name). This way, the program does not need to care

### 377 Student Guide to C++

377 Student Guide to C++ c Mark Corner January 21, 2004 1 Introduction In this course you will be using the C++ language to complete several programming assignments. Up to this point we have only provided

### Pointers II. Class 31

Pointers II Class 31 Compile Time all of the variables we have seen so far have been declared at compile time they are written into the program code you can see by looking at the program how many variables

### THE GOOD, BAD AND UGLY ABOUT POINTERS. Problem Solving with Computers-I

THE GOOD, BAD AND UGLY ABOUT POINTERS Problem Solving with Computers-I The good: Pointers pass data around efficiently Pointers and arrays 100 104 108 112 116 ar 20 30 50 80 90 ar is like a pointer to

### CS24 Week 3 Lecture 1

CS24 Week 3 Lecture 1 Kyle Dewey Overview Some minor C++ points ADT Review Object-oriented Programming C++ Classes Constructors Destructors More minor Points (if time) Key Minor Points const Motivation

### Object-Oriented Programming for Scientific Computing

Object-Oriented Programming for Scientific Computing Dynamic Memory Management Ole Klein Interdisciplinary Center for Scientific Computing Heidelberg University ole.klein@iwr.uni-heidelberg.de 2. Mai 2017

### EL2310 Scientific Programming

Lecture 11: Structures and Memory (yaseminb@kth.se) Overview Overview Lecture 11: Structures and Memory Structures Continued Memory Allocation Lecture 11: Structures and Memory Structures Continued Memory

### Vector and Free Store (Pointers and Memory Allocation)

DM560 Introduction to Programming in C++ Vector and Free Store (Pointers and Memory Allocation) Marco Chiarandini Department of Mathematics & Computer Science University of Southern Denmark [Based on slides

### [0569] p 0318 garbage

A Pointer is a variable which contains the address of another variable. Declaration syntax: Pointer_type *pointer_name; This declaration will create a pointer of the pointer_name which will point to the

### Pointers, Dynamic Data, and Reference Types

Pointers, Dynamic Data, and Reference Types Review on Pointers Reference Variables Dynamic Memory Allocation The new operator The delete operator Dynamic Memory Allocation for Arrays 1 C++ Data Types simple

### Introducing C++ to Java Programmers

Introducing C++ to Java Programmers by Kip Irvine updated 2/27/2003 1 Philosophy of C++ Bjarne Stroustrup invented C++ in the early 1980's at Bell Laboratories First called "C with classes" Design Goals:

### A brief introduction to C++

A brief introduction to C++ Rupert Nash r.nash@epcc.ed.ac.uk 13 June 2018 1 References Bjarne Stroustrup, Programming: Principles and Practice Using C++ (2nd Ed.). Assumes very little but it s long Bjarne

### Copying Data. Contents. Steven J. Zeil. November 13, Destructors 2

Steven J. Zeil November 13, 2013 Contents 1 Destructors 2 2 Copy Constructors 11 2.1 Where Do We Use a Copy Constructor? 12 2.2 Compiler-Generated Copy Constructors............................................

### Pointer Basics. Lecture 13 COP 3014 Spring March 28, 2018

Pointer Basics Lecture 13 COP 3014 Spring 2018 March 28, 2018 What is a Pointer? A pointer is a variable that stores a memory address. Pointers are used to store the addresses of other variables or memory

### Pointers and Dynamic Memory Allocation

Pointers and Dynamic Memory Allocation ALGORITHMS & DATA STRUCTURES 9 TH SEPTEMBER 2014 Last week Introduction This is not a course about programming: It s is about puzzling. well.. Donald Knuth Science

### Pointers and Memory 1

Pointers and Memory 1 Pointer values Pointer values are memory addresses Think of them as a kind of integer values The first byte of memory is 0, the next 1, and so on A pointer p can hold the address

### Dynamic Allocation of Memory

Dynamic Allocation of Memory Lecture 4 Sections 10.9-10.10 Robb T. Koether Hampden-Sydney College Fri, Jan 25, 2013 Robb T. Koether (Hampden-Sydney College) Dynamic Allocation of Memory Fri, Jan 25, 2013

### Defensive Programming

Steven Zeil July 22, 2013 Contents 1 Common Assumptions 2 2 Documenting Assumptions 2 3 Guarding Assumptions 5 3.1 Guarding Assumptions with Assertions............................... 8 1 Defensive Programming

### Fast Introduction to Object Oriented Programming and C++

Fast Introduction to Object Oriented Programming and C++ Daniel G. Aliaga Note: a compilation of slides from Jacques de Wet, Ohio State University, Chad Willwerth, and Daniel Aliaga. Outline Programming

Chapter 10 Pointers and Dynamic Arrays Copyright 2016 Pearson, Inc. All rights reserved. Learning Objectives Pointers Pointer variables Memory management Dynamic Arrays Creating and using Pointer arithmetic

### Patterns: Working with Arrays

Steven Zeil October 14, 2013 Outline 1 Static & Dynamic Allocation Static Allocation Dynamic Allocation 2 Partially Filled Arrays Adding Elements Searching for Elements Removing Elements 3 Arrays and Templates

### CSCI-1200 Data Structures Fall 2018 Lecture 5 Pointers, Arrays, & Pointer Arithmetic

CSCI-1200 Data Structures Fall 2018 Lecture 5 Pointers, Arrays, & Pointer Arithmetic Announcements: Test 1 Information Test 1 will be held Thursday, Sept 20th, 2018 from 6-7:50pm Students will be randomly

### In Java we have the keyword null, which is the value of an uninitialized reference type

+ More on Pointers + Null pointers In Java we have the keyword null, which is the value of an uninitialized reference type In C we sometimes use NULL, but its just a macro for the integer 0 Pointers are

### Lecture 14. No in-class files today. Homework 7 (due on Wednesday) and Project 3 (due in 10 days) posted. Questions?

Lecture 14 No in-class files today. Homework 7 (due on Wednesday) and Project 3 (due in 10 days) posted. Questions? Friday, February 11 CS 215 Fundamentals of Programming II - Lecture 14 1 Outline Static

### The Structure of a C++ Program

Steven Zeil May 25, 2013 Contents 1 Separate Compilation 3 1.1 Separate Compilation.......... 4 2 Pre-processing 7 2.1 #include.................. 9 2.2 Other Pre-processing Commands... 14 3 Declarations

### Short Notes of CS201

#includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system

### Vector and Free Store (Vectors and Arrays)

DM560 Introduction to Programming in C++ Vector and Free Store (Vectors and Arrays) Marco Chiarandini Department of Mathematics & Computer Science University of Southern Denmark [Based on slides by Bjarne

### CS201 - Introduction to Programming Glossary By

CS201 - Introduction to Programming Glossary By #include : The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with

### CSCI-1200 Data Structures Spring 2014 Lecture 5 Pointers, Arrays, Pointer Arithmetic

CSCI-1200 Data Structures Spring 2014 Lecture 5 Pointers, Arrays, Pointer Arithmetic Announcements: Test 1 Information Test 1 will be held Monday, February 10th, 2014 from 6-7:50pm, Lab sections 1-5 and

### CSCI-1200 Data Structures Fall 2012 Lecture 5 Pointers, Arrays, Pointer Arithmetic

CSCI-1200 Data Structures Fall 2012 Lecture 5 Pointers, Arrays, Pointer Arithmetic Announcements: Test 1 Information Test 1 will be held Tuesday, September 18th, 2012 from 2-3:50pm in West Hall Auditorium.

### nptr = new int; // assigns valid address_of_int value to nptr std::cin >> n; // assigns valid int value to n

Static and Dynamic Memory Allocation In this chapter we review the concepts of array and pointer and the use of the bracket operator for both arrays and pointers. We also review (or introduce) pointer

### Principles of Programming Pointers, Dynamic Memory Allocation, Character Arrays, and Buffer Overruns

Pointers, Dynamic Memory Allocation, Character Arrays, and Buffer Overruns What is an array? Pointers Memory issues The name of the array is actually a memory address. You can prove this by trying to print

### Lecture 2, September 4

Lecture 2, September 4 Intro to C/C++ Instructor: Prashant Shenoy, TA: Shashi Singh 1 Introduction C++ is an object-oriented language and is one of the most frequently used languages for development due

### C++ Programming. Pointers and Memory Management. M1 Math Michail Lampis

C++ Programming Pointers and Memory Management M1 Math Michail Lampis michail.lampis@dauphine.fr Dynamic Memory Allocation Data in your program lives (mostly) in two areas The stack The heap So far, we

### Chapter 2. Procedural Programming

Chapter 2 Procedural Programming 2: Preview Basic concepts that are similar in both Java and C++, including: standard data types control structures I/O functions Dynamic memory management, and some basic

### CPSC 427: Object-Oriented Programming

CPSC 427: Object-Oriented Programming Michael J. Fischer Lecture 12 October 10, 2016 CPSC 427, Lecture 12 1/27 Uses of Pointers Custody of Objects Move Semantics CPSC 427, Lecture 12 2/27 Uses of Pointers

### CSCI-1200 Data Structures Spring 2017 Lecture 5 Pointers, Arrays, Pointer Arithmetic

CSCI-1200 Data Structures Spring 2017 Lecture 5 Pointers, Arrays, Pointer Arithmetic Announcements Submitty iclicker registration is still open. Even if you already registered on the iclicker website,

### Functions and Parameter Passing

Chapter 5: Functions and Parameter Passing In this chapter, we examine the difference between function calls in C and C++ and the resulting difference in the way functions are defined in the two languages.

### Arrays and Pointers in C. Alan L. Cox

Arrays and Pointers in C Alan L. Cox alc@rice.edu Objectives Be able to use arrays, pointers, and strings in C programs Be able to explain the representation of these data types at the machine level, including

### Arrays. Returning arrays Pointers Dynamic arrays Smart pointers Vectors

Arrays Returning arrays Pointers Dynamic arrays Smart pointers Vectors To declare an array specify the type, its name, and its size in []s int arr1[10]; //or int arr2[] = {1,2,3,4,5,6,7,8}; arr2 has 8

### CPSC 427: Object-Oriented Programming

CPSC 427: Object-Oriented Programming Michael J. Fischer Lecture 10 October 1, 2018 CPSC 427, Lecture 10, October 1, 2018 1/20 Brackets Example (continued from lecture 8) Stack class Brackets class Main

### Agenda. Peer Instruction Question 1. Peer Instruction Answer 1. Peer Instruction Question 2 6/22/2011

CS 61C: Great Ideas in Computer Architecture (Machine Structures) Introduction to C (Part II) Instructors: Randy H. Katz David A. Patterson http://inst.eecs.berkeley.edu/~cs61c/sp11 Spring 2011 -- Lecture

### Operating Systems CMPSCI 377, Lec 2 Intro to C/C++ Prashant Shenoy University of Massachusetts Amherst

Operating Systems CMPSCI 377, Lec 2 Intro to C/C++ Prashant Shenoy University of Massachusetts Amherst Department of Computer Science Why C? Low-level Direct access to memory WYSIWYG (more or less) Effectively

### Pointers. Addresses in Memory. Exam 1 on July 18, :00-11:40am

Exam 1 on July 18, 2005 10:00-11:40am Pointers Addresses in Memory When a variable is declared, enough memory to hold a value of that type is allocated for it at an unused memory location. This is the

### a data type is Types

Pointers Class 2 a data type is Types Types a data type is a set of values a set of operations defined on those values in C++ (and most languages) there are two flavors of types primitive or fundamental

### FORM 1 (Please put your name and section number (001/10am or 002/2pm) on the scantron!!!!) CS 161 Exam II: True (A)/False(B) (2 pts each):

FORM 1 (Please put your name and section number (001/10am or 002/2pm) on the scantron!!!!) CS 161 Exam II: True (A)/False(B) (2 pts each): 1. If a function has default arguments, they can be located anywhere

### Memory and Pointers written by Cathy Saxton

Memory and Pointers written by Cathy Saxton Basic Memory Layout When a program is running, there are three main chunks of memory that it is using: A program code area where the program itself is loaded.

### pointers + memory double x; string a; int x; main overhead int y; main overhead

pointers + memory computer have memory to store data. every program gets a piece of it to use as we create and use more variables, more space is allocated to a program memory int x; double x; string a;

### These are notes for the third lecture; if statements and loops.

These are notes for the third lecture; if statements and loops. 1 Yeah, this is going to be the second slide in a lot of lectures. 2 - Dominant language for desktop application development - Most modern

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 4 Introduction to C (pt 2) 2014-09-08!!!Senior Lecturer SOE Dan Garcia!!!www.cs.berkeley.edu/~ddgarcia! C most popular! TIOBE programming

### Chapter 10 Pointers and Dynamic Arrays. GEDB030 Computer Programming for Engineers Fall 2017 Euiseong Seo

Chapter 10 Pointers and Dynamic Arrays 1 Learning Objectives Pointers Pointer variables Memory management Dynamic Arrays Creating and using Pointer arithmetic Classes, Pointers, Dynamic Arrays The this

### CPSC 427a: Object-Oriented Programming

CPSC 427a: Object-Oriented Programming Michael J. Fischer Lecture 5 September 15, 2011 CPSC 427a, Lecture 5 1/35 Functions and Methods Parameters Choosing Parameter Types The Implicit Argument Simple Variables

### Chapter 1: Object-Oriented Programming Using C++

Chapter 1: Object-Oriented Programming Using C++ Objectives Looking ahead in this chapter, we ll consider: Abstract Data Types Encapsulation Inheritance Pointers Polymorphism Data Structures and Algorithms

### CSCI-1200 Data Structures Spring 2016 Lecture 6 Pointers & Dynamic Memory

Announcements CSCI-1200 Data Structures Spring 2016 Lecture 6 Pointers & Dynamic Memory There will be no lecture on Tuesday, Feb. 16. Prof. Thompson s office hours are canceled for Monday, Feb. 15. Prof.

### CMSC 341 Lecture 2 Dynamic Memory and Pointers

CMSC 341 Lecture 2 Dynamic Memory and Pointers Park Sects. 01 & 02 Based on earlier course slides at UMBC Today s Topics Stack vs Heap Allocating and freeing memory new and delete Memory Leaks Valgrind

### Objectives. Chapter 2: Basic Elements of C++ Introduction. Objectives (cont d.) A C++ Program (cont d.) A C++ Program

Objectives Chapter 2: Basic Elements of C++ In this chapter, you will: Become familiar with functions, special symbols, and identifiers in C++ Explore simple data types Discover how a program evaluates

### Chapter 2: Basic Elements of C++

Chapter 2: Basic Elements of C++ Objectives In this chapter, you will: Become familiar with functions, special symbols, and identifiers in C++ Explore simple data types Discover how a program evaluates

### CSCI-1200 Data Structures Spring 2018 Lecture 5 Pointers, Arrays, & Pointer Arithmetic

CSCI-1200 Data Structures Spring 2018 Lecture 5 Pointers, Arrays, & Pointer Arithmetic Announcements: Test 1 Information Test 1 will be held Monday, February 5th, 2017 from 6-7:50pm Students will be randomly

### CS201 Some Important Definitions

CS201 Some Important Definitions For Viva Preparation 1. What is a program? A program is a precise sequence of steps to solve a particular problem. 2. What is a class? We write a C++ program using data

### Structure of Programming Languages Lecture 10

Structure of Programming Languages Lecture 10 CS 6636 4536 Spring 2017 CS 6636 4536 Lecture 10: Classes... 1/23 Spring 2017 1 / 23 Outline 1 1. Types Type Coercion and Conversion Type Classes, Generics,

### Chapter 2: Basic Elements of C++ Objectives. Objectives (cont d.) A C++ Program. Introduction

Chapter 2: Basic Elements of C++ C++ Programming: From Problem Analysis to Program Design, Fifth Edition 1 Objectives In this chapter, you will: Become familiar with functions, special symbols, and identifiers

### Lecture Notes on Memory Layout

Lecture Notes on Memory Layout 15-122: Principles of Imperative Computation Frank Pfenning André Platzer Lecture 11 1 Introduction In order to understand how programs work, we can consider the functions,

### CS 161 Exam II Winter 2018 FORM 1

CS 161 Exam II Winter 2018 FORM 1 Please put your name and form number on the scantron. True (A)/False (B) (28 pts, 2 pts each) 1. The following array declaration is legal double scores[]={0.1,0.2,0.3;

### CPSC 427: Object-Oriented Programming

CPSC 427: Object-Oriented Programming Michael J. Fischer Lecture 7 September 21, 2016 CPSC 427, Lecture 7 1/21 Brackets Example (continued) Storage Management CPSC 427, Lecture 7 2/21 Brackets Example

### Errors. Lecture 6. Hartmut Kaiser hkaiser/fall_2011/csc1254.html

Hartmut Kaiser hkaiser@cct.lsu.edu http://www.cct.lsu.edu/ hkaiser/fall_2011/csc1254.html 2 Abstract When we program, we have to deal with errors. Our most basic aim is correctness, but we must deal with

### Outline. 1 Function calls and parameter passing. 2 Pointers, arrays, and references. 5 Declarations, scope, and lifetimes 6 I/O

Outline EDAF30 Programming in C++ 2. Introduction. More on function calls and types. Sven Gestegård Robertz Computer Science, LTH 2018 1 Function calls and parameter passing 2 Pointers, arrays, and references

### CSE 374 Programming Concepts & Tools

CSE 374 Programming Concepts & Tools Hal Perkins Fall 2017 Lecture 8 C: Miscellanea Control, Declarations, Preprocessor, printf/scanf 1 The story so far The low-level execution model of a process (one

### CS 536 Introduction to Programming Languages and Compilers Charles N. Fischer Lecture 11

CS 536 Introduction to Programming Languages and Compilers Charles N. Fischer Lecture 11 CS 536 Spring 2015 1 Handling Overloaded Declarations Two approaches are popular: 1. Create a single symbol table

### Lecture 04 Introduction to pointers

Lecture 04 Introduction to pointers A pointer is an address in the memory. One of the unique advantages of using C is that it provides direct access to a memory location through its address. A variable

### calling a function - function-name(argument list); y = square ( z ); include parentheses even if parameter list is empty!

Chapter 6 - Functions return type void or a valid data type ( int, double, char, etc) name parameter list void or a list of parameters separated by commas body return keyword required if function returns

### A brief introduction to C programming for Java programmers

A brief introduction to C programming for Java programmers Sven Gestegård Robertz September 2017 There are many similarities between Java and C. The syntax in Java is basically

### Pointers. A pointer value is the address of the first byte of the pointed object in the memory. A pointer does not know how many bytes it points to.

Pointers A pointer is a memory address of an object of a specified type, or it is a variable which keeps such an address. Pointer properties: P (pointer) 12316 12316 (address) Typed object A pointer value

### Chapter 17 vector and Free Store

Chapter 17 vector and Free Store Bjarne Stroustrup www.stroustrup.com/programming Overview Vector revisited How are they implemented? Pointers and free store Allocation (new) Access Arrays and subscripting:

### Pointers, Arrays and C-Strings

Pointers, Arrays and C-Strings Data Processing Course, I. Hrivnacova, IPN Orsay Variable in Memory Pointers Nullptr Pointers vs References C-Arrays C-Strings Problems with C-Arrays, C-Strings 1 Variables

### Lesson 13 - Vectors Dynamic Data Storage

Lesson 13 - Vectors Dynamic Data Storage Summary In this lesson we introduce the Standard Template Library by demonstrating the use of Vectors to provide dynamic storage of data elements. New Concepts

### Ch. 11: References & the Copy-Constructor. - continued -

Ch. 11: References & the Copy-Constructor - continued - const references When a reference is made const, it means that the object it refers cannot be changed through that reference - it may be changed

### What is Pointer? Pointer is a variable that holds a memory address, usually location of another variable.

CHAPTER 08 POINTERS What is Pointer? Pointer is a variable that holds a memory address, usually location of another variable. The Pointers are one of the C++ s most useful and powerful features. How Pointers

### Object-Oriented Principles and Practice / C++

Object-Oriented Principles and Practice / C++ Alice E. Fischer September 26, 2016 OOPP / C++ Lecture 4... 1/33 Global vs. Class Static Parameters Move Semantics OOPP / C++ Lecture 4... 2/33 Global Functions

### Reference operator (&)

Pointers Each cell can be easily located in the memory because it has a unique address and all the memory cells follow a successive pattern. For example, if we are looking for cell 1776 we know that it

### CS31 Discussion. Jie(Jay) Wang Week8 Nov.18

CS31 Discussion Jie(Jay) Wang Week8 Nov.18 Outline Pointer Struct Memory Management When the program gets executed, it gets some amount of memory allocated for use. memory Program 1 Program 2 Memory Management

### Stack memory - "scratch pad" memory that is used by automatic variables.

Dynamic Memory Allocation In C and C++ three types of memory are used by programs: Static memory - where global and static variables live Stack memory - "scratch pad" memory that is used by automatic variables.

### Dynamic Allocation of Memory

Dynamic Allocation of Memory Lecture 5 Section 9.8 Robb T. Koether Hampden-Sydney College Wed, Jan 24, 2018 Robb T. Koether (Hampden-Sydney College) Dynamic Allocation of Memory Wed, Jan 24, 2018 1 / 34

### Bruce Merry. IOI Training Dec 2013

IOI Training Dec 2013 Outline 1 2 3 Outline 1 2 3 You can check that something is true using assert: #include int main() { assert(1 == 2); } Output: test_assert: test_assert.cpp:4: int main():

### QUIZ. What are 3 differences between C and C++ const variables?

QUIZ What are 3 differences between C and C++ const variables? Solution QUIZ Source: http://stackoverflow.com/questions/17349387/scope-of-macros-in-c Solution The C/C++ preprocessor substitutes mechanically,

### CSCI 262 Data Structures. Arrays and Pointers. Arrays. Arrays and Pointers 2/6/2018 POINTER ARITHMETIC

CSCI 262 Data Structures 9 Dynamically Allocated Memory POINTERS AND ARRAYS 2 Arrays Arrays are just sequential chunks of memory: Arrays and Pointers Array variables are secretly pointers: x19 x18 x17

### Review of Important Topics in CS1600. Functions Arrays C-strings

Review of Important Topics in CS1600 Functions Arrays C-strings Array Basics Arrays An array is used to process a collection of data of the same type Examples: A list of names A list of temperatures Why

### Constants, References

CS 246: Software Abstraction and Specification Constants, References Readings: Eckel, Vol. 1 Ch. 8 Constants Ch. 11 References and the Copy Constructor U Waterloo CS246se (Spring 2011) p.1/14 Uses of const

### Modern C++ for Computer Vision and Image Processing. Igor Bogoslavskyi

Modern C++ for Computer Vision and Image Processing Igor Bogoslavskyi Outline Using pointers Pointers are polymorphic Pointer this Using const with pointers Stack and Heap Memory leaks and dangling pointers

### CPSC 427: Object-Oriented Programming

CPSC 427: Object-Oriented Programming Michael J. Fischer Lecture 11 October 3, 2018 CPSC 427, Lecture 11, October 3, 2018 1/24 Copying and Assignment Custody of Objects Move Semantics CPSC 427, Lecture