📖
C++
  • 1. C++ Basics
    • 1.1 Input, Output, and Program Structure
      • 1.1.1 Welcome to Data Structures in C++
      • 1.1.2 Hello World
      • 1.1.3 Input and Output
      • 1.1.4 getline and cin
      • 1.1.5 Program Structure
    • 1.2 Basic Data Types
      • 1.2.1 Basic Data Types
        • 1.2.1.1 Differences between C++ and Java Data Types and Variables
      • 1.2.2 Strings and Characters
      • 1.2.3 Numbers
      • 1.2.4 Booleans
    • 1.3 Conditional Statements
      • 1.3.1 Conditional Statements
      • 1.3.2 Basic If/Else Statements
      • 1.3.3 Comparing Strings
      • 1.3.4 Logical Operators
    • 1.4 Loops
      • 1.4.1 Loops
      • 1.4.2 For Loops
      • 1.4.3 While Loops
      • 1.4.4 Searching a String
    • 1.5 Functions in C++
      • 1.5.1 Functions in C++
      • 1.5.2 Defining and Calling Functions
      • 1.5.3 Passing by Reference vs Value
      • 1.5.4 Function Prototypes
  • 2. Going Beyond the Basics
    • 2.1 Vector Basics
      • 2.1.1 Vector Basics
      • 2.1.2 Creating and Accessing Vectors
      • 2.1.3 Inserting into a Vector
      • 2.1.4 Looping Through a Vector
    • 2.2 Function Default Values
      • 2.2.1 Function Default Values
      • 2.2.2 Default Values
      • 2.2.3 Default Values with a Prototype
      • 2.2.4 Example: Splitting a String
    • 2.3 Structs
      • 2.3.1 Structs
      • 2.3.2 Defining and Accessing Structs
      • 2.3.3 Using Structs: Line Length
    • 2.4 File Input/Output
      • 2.4.1 File Input/Output
      • 2.4.2 Reading in a File
      • 2.4.3 Processing a File
      • 2.4.4 Writing to a File
      • 2.4.5 Creating an Input Stream from a String
    • 2.5 Error Handling
      • 2.5.1 Error Handling
      • 2.5.2 Validating a Number
      • 2.5.3 Validating a Vector Index
      • 2.5.4 Throwing Other Values
  • 3. Libraries
    • 3.1 Header Files
      • 3.1.1 Header Files
      • 3.1.2 Header File
      • 3.1.3 Header and Implementation File
      • 3.1.4 Safer Header
    • 3.2 Using Libraries
      • 3.2.1 Using a Utilities Library
      • 3.2.2 The Util Library
  • 4. 2D Vectors, Stacks, and Queues
    • 4.1 2D Vectors
      • 4.1.1 2D Vectors
      • 4.1.2 The 2D Vector
      • 4.1.3 Creating a 2D Vector
    • 4.3 Stacks
      • 4.3.1 Stacks
      • 4.3.2 Basic Stack
      • 4.3.3 Stack Example: Reverse a String
    • 4.5 Queues
      • 4.5.1 Queues
      • 4.5.2 Basic Queues
      • 4.5.3 Queue Example: Next in Line
  • 5. Sets and Maps
    • 5.1 Pairs and Iterators
      • 5.1.1 Pairs and Iterators
      • 5.1.2 Pairs
      • 5.1.3 Iterators
    • 5.3 Sets
      • 5.3.1 Sets
      • 5.3.2 Basic Sets
      • 5.3.3 Iterating Through a Set
      • 5.3.4 Sets of Struct Values
    • 5.4 Maps
      • 5.4.1 Maps
      • 5.4.2 Map Basics
      • 5.4.3 Iterating Through a Map
      • 5.4.4 Updating Maps
  • 6. Recursion
    • 6.1 Functional Recursion
      • 6.1.1 Functional Recursion
      • 6.1.2 Basic Recursive Problem: Exponential
      • 6.1.3 Recursion Example: Reverse String
      • 6.1.4 Recursion Example: Make Sum
    • 6.2 Procedural Recursion
      • 6.2.1 Procedural Recursion
      • 6.2.2 Print Binary
      • 6.2.3 Print Permutations
      • 6.2.4 Depth vs Breadth Search
  • 7. Pointers, Linked Lists, and Graphs
    • 7.1 Pointers
      • 7.1.1 Pointers
      • 7.1.2 Assigning and Updating Pointers
      • 7.1.3 Pointers and Functions
      • 7.1.4 Pointers and Data Structures
    • 7.2 Linked Lists
      • 7.2.1 Linked Lists
      • 7.2.2 Basic Linked List
      • 7.2.3 Linked List and Recursion
      • 7.2.4 Example: Sorted Phone Book
      • 7.2.5 Doubly Linked List
    • 7.3 Graphs
      • 7.3.1 Graphs
      • 7.3.2 Basic Example: Breadth First Search
      • 7.3.3 Application: Connecting Cities
Powered by GitBook
On this page
  • Data Structure of Pointers
  • Pointer Data Structure of Values
  • The Arrow Operator
  • Try This Example
  1. 7. Pointers, Linked Lists, and Graphs
  2. 7.1 Pointers

7.1.4 Pointers and Data Structures

In this final example, you are going to explore how pointers impact data structures such as vectors, stacks, maps, etc. While the implementation is a variation on what you have already seen, there is a new syntax shortcut that will become an important tool in your toolbox.

Data Structure of Pointers

As you think of data structures and pointers, there are two scenarios. The first is a standard data structure that stores pointers.

In this case, the syntax is very similar to what you have seen so far. You create the data structure as you would usually:

queue<int*> nums;

int *num1;
num1 = new int;
*num1 = 50;
nums.push(num1);

cout << *nums.front() << endl;
nums.pop();

Notice that the data type for the queue is int*, which creates a queue of integer pointers. Once you have an integer pointer, it can be added to the queue.

To access the pointer, you access just like any other queue data type, however, if you want to get the value, you need to dereference after accessing it. Notice that you do not need to dereference the value when you remove it with pop.

It is important to note that the * is applied to nums.front() because it is nums.front() that returns the pointer.

Pointer Data Structure of Values

The second scenario is when you have a data structure that is in itself a pointer but holds actual values. In this case, the declaration is similar to declaring any other pointer variable, including creating a space in the heap.

For example, a pointer queue of integers would get declared like this:

queue<int> *nums;
nums = new queue<int>;

To call functions such as push, you must first dereference the data structure. Once the data structure is dereferenced, you can call the function.

(*nums).push(20);

Notice this time that the dereference only applies to the data structure name, not to the entire function call. With this in mind, the data structure needs parenthesis to force the dereference before the function call.

The Arrow Operator

Pointer data structures (or referenced data structures) including a struct pointer are common in C++, so to avoid having to use the * and ( )., an arrow -> can be used instead:

Equivalent Statements:

(*nums).push(20);
nums->push(20);

The former is seldom used in practice and this course will exclusively use the latter to represent calls to functions of pointer data structures.

Remember, the arrow operator is used in place of the dot anytime the root data structure is a pointer. This applies to things like queues, maps, etc, but also applies to things like pairs and structs.

Previous7.1.3 Pointers and FunctionsNext7.2 Linked Lists

Last updated 3 years ago

Try This Example