9.11 — Pointer arithmetic and array indexing

By Alex on August 15th, 2015 | last modified by nascardriver on January 26th, 2021

Pointer arithmetic

The C++ language allows you to perform integer addition or subtraction operations on pointers. If ptr points to an integer, ptr + 1 is the address of the next integer in memory after ptr. ptr - 1 is the address of the previous integer before ptr.

Note that ptr + 1 does not return the memory address after ptr, but the memory address of the next object of the type that ptr points to. If ptr points to an integer (assuming 4 bytes), ptr + 3 means 3 integers (12 bytes) after ptr. If ptr points to a char, which is always 1 byte, ptr + 3 means 3 chars (3 bytes) after ptr.

When calculating the result of a pointer arithmetic expression, the compiler always multiplies the integer operand by the size of the object being pointed to. This is called scaling.

Consider the following program:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <iostream>   int main() {     int value{ 7 };     int *ptr{ &value };       std::cout << ptr << '\n';     std::cout << ptr+1 << '\n';     std::cout << ptr+2 << '\n';     std::cout << ptr+3 << '\n';       return 0; }

On the author’s machine, this output:

0012FF7C
0012FF80
0012FF84
0012FF88

As you can see, each of these addresses differs by 4 (7C + 4 = 80 in hexadecimal). This is because an integer is 4 bytes on the author’s machine.

The same program using short instead of int:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <iostream>   int main() {     short value{ 7 };     short *ptr{ &value };       std::cout << ptr << '\n';     std::cout << ptr+1 << '\n';     std::cout << ptr+2 << '\n';     std::cout << ptr+3 << '\n';       return 0; }

On the author’s machine, this output:

0012FF7C
0012FF7E
0012FF80
0012FF82

Because a short is 2 bytes, each address differs by 2.

Arrays are laid out sequentially in memory

By using the address-of operator (&), we can determine that arrays are laid out sequentially in memory. That is, elements 0, 1, 2, … are all adjacent to each other, in order.

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <iostream>   int main() {     int array[]{ 9, 7, 5, 3, 1 };       std::cout << "Element 0 is at address: " << &array[0] << '\n';     std::cout << "Element 1 is at address: " << &array[1] << '\n';     std::cout << "Element 2 is at address: " << &array[2] << '\n';     std::cout << "Element 3 is at address: " << &array[3] << '\n';       return 0; }

On the author’s machine, this printed:

Element 0 is at address: 0041FE9C
Element 1 is at address: 0041FEA0
Element 2 is at address: 0041FEA4
Element 3 is at address: 0041FEA8

Note that each of these memory addresses is 4 bytes apart, which is the size of an integer on the author’s machine.

Pointer arithmetic, arrays, and the magic behind indexing

In the section above, you learned that arrays are laid out in memory sequentially.

In the previous lesson, you learned that a fixed array can decay into a pointer that points to the first element (element 0) of the array.

Also in a section above, you learned that adding 1 to a pointer returns the memory address of the next object of that type in memory.

Therefore, we might conclude that adding 1 to an array should point to the second element (element 1) of the array. We can verify experimentally that this is true:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <iostream>   int main() {      int array []{ 9, 7, 5, 3, 1 };        std::cout << &array[1] << '\n'; // print memory address of array element 1      std::cout << array+1 << '\n'; // print memory address of array pointer + 1        std::cout << array[1] << '\n'; // prints 7      std::cout << *(array+1) << '\n'; // prints 7 (note the parenthesis required here)       return 0; }

Note that when performing indirection through the result of pointer arithmetic, parenthesis are necessary to ensure the operator precedence is correct, since operator * has higher precedence than operator +.

On the author’s machine, this printed:

0017FB80
0017FB80
7
7

It turns out that when the compiler sees the subscript operator ([]), it actually translates that into a pointer addition and indirection! Generalizing, array[n] is the same as *(array + n), where n is an integer. The subscript operator [] is there both to look nice and for ease of use (so you don’t have to remember the parenthesis).

Using a pointer to iterate through an array

We can use a pointer and pointer arithmetic to loop through an array. Although not commonly done this way (using subscripts is generally easier to read and less error prone), the following example goes to show it is possible:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

#include <iostream> #include <iterator> // for std::size   bool isVowel(char ch) {   switch (ch)   {   case 'A':   case 'a':   case 'E':   case 'e':   case 'I':   case 'i':   case 'O':   case 'o':   case 'U':   case 'u':     return true;   default:     return false;   } }   int main() {   char name[]{ "Mollie" };   int arrayLength{ static_cast<int>(std::size(name)) };   int numVowels{ 0 };     for (char *ptr{ name }; ptr < (name + arrayLength); ++ptr)   {     if (isVowel(*ptr))     {       ++numVowels;     }   }     std::cout << name << " has " << numVowels << " vowels.\n";     return 0; }

How does it work? This program uses a pointer to step through each of the elements in an array. Remember that arrays decay to pointers to the first element of the array. So by assigning ptr to name, ptr will also point to the first element of the array. Indirection through ptr is performed for each element when we call isVowel(*ptr), and if the element is a vowel, numVowels is incremented. Then the for loop uses the ++ operator to advance the pointer to the next character in the array. The for loop terminates when all characters have been examined.

The above program produces the result:

Mollie has 3 vowels

Because counting elements is common, the algorithms library offers std::count_if, which counts elements that fulfill a condition. We can replace the for-loop with a call to std::count_if.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

#include <algorithm> #include <iostream> #include <iterator> // for std::begin and std::end   bool isVowel(char ch) {   switch (ch)   {   case 'A':   case 'a':   case 'E':   case 'e':   case 'I':   case 'i':   case 'O':   case 'o':   case 'U':   case 'u':     return true;   default:     return false;   } }   int main() {   char name[]{ "Mollie" };   auto numVowels{ std::count_if(std::begin(name), std::end(name), isVowel) };     std::cout << name << " has " << numVowels << " vowels.\n";     return 0; }

std::begin returns an iterator (pointer) to the first element, while std::end returns an iterator to the element that would be one after the last. The iterator returned by std::end is only used as a marker, accessing it causes undefined behavior, because it doesn’t point to a real element.

std::begin and std::end only work on arrays with a known size. If the array decayed to a pointer, we can calculate begin and end manually.

1 2 3 4 5

// nameLength is the number of elements in the array. std::count_if(name, name + nameLength, isVowel)   // Don't do this. Accessing invalid indexes causes undefined behavior. // std::count_if(name, &name[nameLength], isVowel)

Note that we’re calculating name + nameLength, not name + nameLength - 1, because we don’t want the last element, but the pseudo-element one past the last.

Calculating begin and end of an array like this works for all algorithms that need a begin and end argument.

Quiz time

Question #1

Why does the following code work?

1 2 3 4 5 6 7 8 9 10

#include <iostream>   int main() {   int arr[]{ 1, 2, 3 };     std::cout << 2[arr] << '\n';     return 0; }

Show Solution

The subscript operator ([]) is identical to an addition and an indirection, the operands can be swapped.

1 2 3 4 5 6 7

arr[2] // same as *(arr + 2) // same as *(2 + arr) // same as 2[arr]

It’s an interesting observation, but don’t use this syntax in real code. This only works for the built-in subscript operator. You’ll learn about types with custom operators where this doesn’t work later.

Question #2

Write a function named find that takes a pointer to the beginning and a pointer to the end (1 element past the last) of an array, as well as a value. The function should search for the given value and return a pointer to the first element with that value, or the end pointer if no element was found. The following program should run:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include <iostream> #include <iterator>   // ...   int main() {     int arr[]{ 2, 5, 4, 10, 8, 20, 16, 40 };       // Search for the first element with value 20.     int *found{ find(std::begin(arr), std::end(arr), 20) };       // If an element with value 20 was found, print it.     if (found != std::end(arr))     {         std::cout << *found << '\n';     }       return 0; }

Tip

std::begin and std::end return an int*. The call to find is equivalent to

1	int *found{ find(arr, arr + std::size(arr), 20) };

Show Solution

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

#include <iostream> #include <iterator>   int* find(int *begin, int *end, int value) {     for (int *p{ begin }; p != end; ++p)     {         if (*p == value)         {             return p;         }     }       return end; }   int main() {     int arr[]{ 2, 5, 4, 10, 8, 20, 16, 40 };       int *found{ find(std::begin(arr), std::end(arr), 20) };       if (found != std::end(arr))     {         std::cout << *found << '\n';     }       return 0; }

Tip

find is a standard function:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include <algorithm> // std::find #include <iostream> #include <iterator>   int main() {     int arr[]{ 2, 5, 4, 10, 8, 20, 16, 40 };       // Note: std::find returns an iterator, we'll talk about iterators later.     auto found{ std::find(std::begin(arr), std::end(arr), 20) };       if (found != std::end(arr))     {         std::cout << *found << '\n';     }       return 0; }

9.12 -- C-style string symbolic constants

Index

9.10 -- Pointers and arrays

C++ Tutorial |  Print This Post

263 comments to 9.11 — Pointer arithmetic and array indexing

• Innervate

  August 21, 2020 at 3:25 am · Reply

  I threw up some sample code to help me understand indexing and sorting better:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  #include <iostream> #include <algorithm>   int main() {     int Array[] {3,1,4,6,5,7,2};     int ArraySize { sizeof(Array) / sizeof(Array[0])};          for (const int& Iterate : Array)     {         std::cout << Iterate << ' ';     }          std::cout << '\n';          std::sort(Array , (Array + (ArraySize - 1)));          for (const int& Iterate : Array)     {         std::cout << Iterate << ' ';     }              return 0; }

  My code doesn't sort the last element of the array in this instance. Why is it the case that we would use:
  std::sort(Array , (Array + ArraySize));
  instead of:
  std::sort(Array , (Array + (ArraySize - 1)));

  isn't the first instance more than the number of elements in the array? I am not understanding why it works.

  thanks!

  • nascardriver

    August 21, 2020 at 9:17 am · Reply

    Algorithms want to have the one-past-the-end element. The algorithms will never access this element, it's only used as a marker.
    The reason for this is that not all containers can quickly access their last element (eg. a linked list). Finding the last element could take a long time depending on the data, but creating an end marker is a constant time operation.

• Daniel Glover

  August 9, 2020 at 5:48 am · Reply

  Hello, I'm really having a hard time understanding this part of your code

  1	for (char *ptr{ name }; ptr < (name + arrayLength); ++ptr)

  The part I actually don't understand is this:

  1	(name + arrayLength);

  How does it work actually?

  • nascardriver

    August 9, 2020 at 5:59 am · Reply

    `name + 0` returns the first character.
    `name + 1` returns the second character.
    ...
    `name + arrayLength` returns the one-past-the-end character.

    • Zuhail

      August 11, 2020 at 8:41 am · Reply

      Don't you mean 'name+0' returns the first character address?

      • nascardriver

        August 12, 2020 at 6:13 am · Reply

        Yes, thanks! `name + 0` returns a pointer to the first character. Same for my other examples.

• Galih

  August 6, 2020 at 12:03 pm · Reply

  What can go wrong if i return back begin pointer? I mean if the number is not found, begin == end right?

  1 2 3 4 5 6 7 8 9 10 11

  int* find(int* begin, int* end, int num) {     for(; begin < end; ++begin)     {         if(*begin == num)         {             break;         }     }     return begin; }

  • nascardriver

    August 8, 2020 at 3:45 am · Reply

    There's no difference, other than that it might take a little longer to understand why you're returning `begin`.

• Tony

  August 5, 2020 at 10:24 am · Reply

  Hi @nascardriver. I've completed Question 2 like this:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  int* find(int *begin, int *end, int value) {     for (begin; begin < end; ++begin)     if (*begin == value)     {         return begin;     }          return end; }   int main() {     int arr[]{ 2, 5, 4, 10, 8, 20, 16, 40 };     find(std::begin(arr), std::end(arr), 20);     // Search for the first element with value 20.     int *found{ find(std::begin(arr), std::end(arr), 20) };     // If an element with value 20 was found, print it.     if (found != std::end(arr))     {         std::cout << *found << '\n';     }     return 0; }

  "begin" in this case would be the same as "int *ptr[begin]", or am I wrong? Since begin is an array, and passed into a function, it decays into a pointer that points at the first element of the array. Have I gotten anything wrong?

  Thanks!

  • nascardriver

    August 6, 2020 at 4:40 am · Reply

    You can use `begin` like that. I don't like doing it, because once you increment `begin`, the name "begin" is no longer accurate.

    `begin;` in line 3 doesn't do anything. If you don't want to declare anything, leave the init-statement empty.

    1	for (; begin < end; ++begin)

    If the body of something exceeds 1 line (and even if it doesn't, I suggest doing so), wrap it in curly braces. Together with your missing indentation, your loop body is misleading.

• Lucky Abby

  August 2, 2020 at 6:10 am · Reply

  I dont understand the mechanism of the below code:

  if:

  1	bool isVowel(char ch)

  needs 1 argument,

  but the below statement showing no parameter for the isVowel function call:

  1	auto numVowels{ std::count_if(std::begin(name), std::end(name), isVowel) };

  • nascardriver

    August 3, 2020 at 5:21 am · Reply

    `isVowel` is not a call. We're passing the `isVowel` function itself to `std::count_if` and `std::count_if` later calls it with an argument.

    • Lucky Abby

      August 3, 2020 at 6:35 am · Reply

      Thank you, actually I just found the explanation about this at chapter 6.18. it is function pointer or lambda.

• Joshua

  July 11, 2020 at 10:32 am · Reply

  Oh my! The joy I felt when my code for Q2 matched up EXACTLY to what you'd written. Thanks! I'm having a great time with this!

• Periklis

  June 13, 2020 at 8:52 am · Reply

  1 2 3 4 5 6 7 8 9 10 11 12

  int* find(int *begin, int *end, int value) {     for (int *p{ begin }; p != end; ++p)     {         if (*p == value)         {             return p;         }     }     return end; }

  This is the solution that you presented for quiz 2!

  why you are using p != end instead of p < end ?

  • nascardriver

    June 14, 2020 at 12:16 am · Reply

    As long as we're using pointers, we could use `p < end`. However, the solution shown in the quiz works for all iterators (Iterators are covered later. Pointers into arrays are iterators). Not all iterators support `p < end`, but almost all iterators support `p != end`.

    • Periklis

      June 14, 2020 at 1:18 am · Reply

      Great thank you for the clarification! I am looking forward to read the topic on iterators.

• RJ

  June 11, 2020 at 11:25 pm · Reply

  To summarize this lesson in my own words. Please let me know if i'm wrong.

  When performing operations on non-derefenced pointers, literals are implicitly converted to their size in bytes and multiplied by the literal itself. Basicly the same as using the sizeof() funcion and multiplying that result by the value passed in as an argument. These values are also treated as hex values.

  • nascardriver

    June 12, 2020 at 3:46 am · Reply

    You got the first part right.
    Hexadecimal is just a representation, it doesn't change the value of anything and "a hex value" has no meaning. It doesn't matter if you call your friend Joseph or Joe, it's still the same person.

• shawn

  June 6, 2020 at 10:54 am · Reply

  Why do you recommend using *ptr on an earlier lesson but then use int* ptr in solution to question #2?

  If I remember right, the recommendation was to use *ptr function_name, but with variables to use int *variable_name.

  • nascardriver

    June 7, 2020 at 12:49 am · Reply

    Hi!

    I wrote the examples with `type* name` syntax, you'll see more of them. I'm starting to update these examples to use `type *name` as well.

• Alek

  May 27, 2020 at 4:20 am · Reply

  hey!,I got a question about this part :

  1	auto numVowels{ std::count_if(std::begin(name), std::end(name), isVowel) };

  isVowel is a function yet you are kind of calling it here like :isVowel ? no paranthesis"()" it expects a parameter and we're not giving it any how does it know to pass each elemnts of begin to it ?I struggled too much but it doesn't seem I cant get,also I checked cppreference which had scarrier exp xD here it is :

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  int main() {     std::vector<int> v{ 1, 2, 3, 4, 4, 3, 7, 8, 9, 10 }; //I know about vectors that's not what I mean by scary.     // determine how many integers in a std::vector match a target value.     int target1 = 3;     int target2 = 5;     int num_items1 = std::count(v.begin(), v.end(), target1);     int num_items2 = std::count(v.begin(), v.end(), target2);     std::cout << "number: " << target1 << " count: " << num_items1 << '\n';     std::cout << "number: " << target2 << " count: " << num_items2 << '\n';     // use a lambda expression to count elements divisible by 3.     int num_items3 = std::count_if(v.begin(), v.end(), [](int i){return i % 3 == 0;});     std::cout << "number divisible by three: " << num_items3 << '\n'; }

  can you tell me what's happening in the count_if part ? the third parameter isn't vivid for me "[](int i)"? what is this,never seen such a syntax.
  can you pls tell me the difference between "count"& "count_if" ? count seems like to work like the count_if you utilized above.
  thanks in advance!

  • nascardriver

    May 27, 2020 at 7:29 am · Reply

    When a function is used without parentheses() it's a function pointer. We cover function pointers later. `std::count_if` is calling `isVowel` with each element (character) of `name`. The example on cppreference uses a lambda (anonymous function). We show lambdas in chapter 7.

• koe

  May 14, 2020 at 8:09 am · Reply

  In the std::count_if example I get an error using 'auto' for the numVowels. Instead, the type has to be 'long'. Compiler: Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn)

  • nascardriver

    May 15, 2020 at 3:47 am · Reply

    What's the error message? If you're still not using C++17, try using direct initialization

    1	auto numVowels(std::count_if(std::begin(name), std::end(name), isVowel));

    `auto` didn't work well with list initialization before C++17.

• Gabe

  April 20, 2020 at 3:52 pm · Reply

  Quiz 2

  I recommend stepping through with break points with this one. It's interesting to see
  how it works at a low level! :)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  int* find(int *start, int *end, int val) {     for(int *x{start}; x != end; ++x)     {         if(*x == val)             return x;           // else continue searching     } }   int main() {     int arr[]{ 2, 5, 4, 10, 8, 20, 16, 40 };       // Search for the first element with value 20.     int* found{ find(std::begin(arr), std::end(arr), 20) };       // If an element with value 20 was found, print it.     if (found != std::end(arr))     {         std::cout << *found << '\n';     }       return 0; }

• Carl

  April 12, 2020 at 11:10 am · Reply

  Question 2:
  Have I misunderstood? "....The function should search for the given value and
  return a pointer to the first element with that value,
  or the end pointer if no element was found....."

  The solution as written returns the value 20 not a pointer to the element hence I finished up with:-

  1 2 3 4

  if (found != std::end(arr))     {         std::cout << found << '\n';     }

  • nascardriver

    April 13, 2020 at 4:01 am · Reply

    The solution returns a pointer to the element with value 20, because that element existed. If there was no element with value 20, it'd return `end`. Have another look at the solution, we're returning an `int*`, not an `int`.

    • Carl

      April 13, 2020 at 10:35 am · Reply

      Being pedantic the question asks for '..return a pointer to the first element with that value.' not the value of the element which was the reason for my confusion. I understood the solution as written. Thanks.

      Can I also add here what a godsend this site has been over the foregoing few weeks. Being basically housebound because of this blasted virus it is a great help to have some 'mind fodder'. Thank you.

      • nascardriver

        April 14, 2020 at 5:54 am · Reply

        Exactly, you wrote in your original comment that "The solution as written returns the value 20". But that's not true. The quiz didn't ask to return a value and it doesn't return a value. It always talks about a pointer. The pointer points to an element with the value 20.

• Robbas

  April 10, 2020 at 5:40 am · Reply

  Hi Nascar and Alex, I have a problem with the cout. I can't extract the address for each element of the array.
  I tried with the printf and as you can see it works, where am I doing wrong?

  1 2 3 4 5 6 7 8 9

  char name[]{ "Mollie" };     int arrayLength{ static_cast<int>(std::size(name)) };     int numVowels{ 0 };       for (int i = 0; i < arrayLength-1; ++i)     {         printf("name address [%d]: %p , %c\n", i, &name[i], name[i]);         std::cout << "name address [" << i << "]: " << &name[i] << " , " << name[i] << "\n\n";     }

  Output:
  name address [0]: 002DFC84 , M
  name address [0]: Mollie , M

  name address [1]: 002DFC85 , o
  name address [1]: ollie , o

  name address [2]: 002DFC86 , l
  name address [2]: llie , l

  name address [3]: 002DFC87 , l
  name address [3]: lie , l

  name address [4]: 002DFC88 , i
  name address [4]: ie , i

  name address [5]: 002DFC89 , e
  name address [5]: e , e

  P.S. I checked arrayLength and it's 7 , because it's Mollie + \0, shouldn't it be arrayLength -1 in the for?
  from 0 to 5 it checked all the letters, to 6 it checks \0, is this step necessary?  

  1 2 3 4 5

  char name[]{ "Mollie" };   int arrayLength{ static_cast<int>(std::size(name)) };   int numVowels{ 0 };   for (char* ptr{ name }; ptr < (name + arrayLength); ++ptr)

  I tried with arrayLength-1 and it works so I'm a little confused in this part.

  Thank you in advance

  • nascardriver

    April 12, 2020 at 4:50 am · Reply

    You don't need to print the zero-terminator. You can ignore it or use it as your loop's condition.

    You're printing

    1

    &name[i]

    The type of `name` is `char*` (A string).
    The type of `name[i]` is `char`.
    The type of `&name[i]` is `char*` (A string).

    If you don't want `std::cout` to print a string, cast `&name[i]` to a `void*` first. We cover `void*` later in this chapter.

    1	std::cout << static_cast<void*>(&name[i]) << '\n';

• Dudz

  April 8, 2020 at 11:57 pm · Reply

  My answer for question 2.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

  #include <iostream> #include <iterator>   // ... int* find(int *begin, int *end, int numToFind) {     for (int* currentSearch{ begin }; currentSearch < end; ++currentSearch)     {         if (*currentSearch == numToFind)             return currentSearch;     }     return end; }   int main() {     int arr[]{ 2, 5, 4, 10, 8, 20, 16, 40 };       // Search for the first element with value 20.     int* found{ find(std::begin(arr), std::end(arr), 20) };       // If an element with value 20 was found, print it.     if (found != std::end(arr))     {         std::cout << *found << '\n';     }       return 0; }

• Abhinandan goya;

  March 22, 2020 at 1:05 am · Reply

  what's the problem in this code

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

  #include <iostream> using namespace std; bool isvowel(char a) {switch(a)   {case 'A':   case 'a':   case 'E':   case 'e':   case 'I':   case 'i':   case 'O':   case 'o':   case 'U':   case 'u':     return true;   default:     return false;   }}   int main() {int h=0; char b[]{"asdfghjklo"}; int arraylength=10; for(int i=0;i<10;i++) {if(isvowel('char[i]'))     h+=1; } cout<<"number of vowels ="<<h<<endl;                     }

  • nascardriver

    March 22, 2020 at 1:15 am · Reply

    - You're `using namespace`
    - You're not using list initialization
    - Your variables aren't named descriptively
    - You're using postfix++ instead of ++prefix
    - You're using `std::endl` when you don't need it
    - Your warning level is too low or you're ignoring compiler warnings (Lesson 0.10, 0.11)
    - Your code is inconsistently formatted. Use an auto-formatter to save time

• salah

  March 14, 2020 at 7:00 am · Reply

  Hi, I did not understand this statament well could you illustrate it please

  When calculating the result of a pointer arithmetic expression, the compiler always multiplies the integer operand by the size of the object being pointed to. This is called scaling.

  • Alex

    March 14, 2020 at 4:30 pm · Reply

    Basically, if you have a 32-bit integer (4 bytes), when you advance an int pointer by 2, it will multiple 2 by 4 to get 8. That 8 is the number of memory addresses it needs to move forward.

  • nascardriver

    March 15, 2020 at 1:39 am · Reply

    1

    a + 2

    is

    1	addressof(a) + sizeof(a) * 2

    This makes more sense than just adding 2 to the address, because you'd end up somewhere inside the object and you'd read junk. The automatic multiplication by the object's size makes it so that you get to the next object instead.

• Sam

  March 3, 2020 at 6:34 pm · Reply

  Here is my solution for Problem #2 in the quiz.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  #include <iostream>   int* find(int* begin_ptr, int* end_ptr, const int to_find) {     while (begin_ptr != end_ptr) {         if (*begin_ptr == to_find)             return begin_ptr;         else             ++begin_ptr;     }     return end_ptr; }   int main() {     int arr[] = { 2, 5, 4, 10, 8, 20, 16, 40 };       // search for the first element with value 20.     int* found{ find(std::begin(arr), std::end(arr), 20) };       // if an element with value 20 was found, print it.     if (found != std::end(arr))         std::cout << *found << '\n';       return 0; }

  • nascardriver

    March 6, 2020 at 10:13 am · Reply

    Hi, good job!

    When you know how often your loop is going to run, a `for`-loop is usually the better choice.

• hausevult

  March 2, 2020 at 11:04 pm · Reply

  Hello nascardriver, I am trying to make sure I fully understand how to go about Quiz #2 in a very basic way, but I ran into a problem which quite frankly should not be happening. Am I missing something here?

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  #include <iostream>     int main() {     //defines array with no 20 integer value in any element     //array length (arrLength) defined before array decay     int arr[] = {2, 5, 4, 10, 8, 15, 16, 40};     int arrLength = sizeof(arr) / sizeof(arr[0]);       //integer pointer "found" set as null pointer     int *found = NULL;       //iterating throught every element of array arr     for (int *start = arr; start <= (arr + arrLength); ++start)     {         //start pointer deferred to compare against 20 literal         if (*start == 20)             //memory address of start assigned to pointer found             found = start;     }       //after the loop, if the pointer "found" is not equal to the integer after the last of the array     if (found != arr + arrLength)         std::cout << *found << '\n';         //then print deference of pointer found     else         std::cout << "20 not found.\n";         //else print that 20 was not found in comparisons       return 0; }

  Unfortunately, this crashes the program and results in the following error:
  Process returned -1073741819 (0xC0000005)

  Going over the lesson, I do not understand what I could have done wrong here. I hope you can help me :)

  • hausevult

    March 4, 2020 at 1:11 pm · Reply

    I now see and have resolved my own error. As I was accessing elements in array "arr[8]", I did not take into account the issue caused by accessing and copying out-of-bounds addresses, such as "arr + arrLength", and that it will yield undefined behavior, causing a segmentation fault error... sometimes. Initially I had thought to assign pointer "found" the address that immediately follows the last address in the array, and to compare as to whether "found" held this address later on. But I realized that this was completely unnecessary, and that I could instead in line 24 I should have used the boolean comparison functionality of null pointers, rather than arbitrarily choosing to set "found" to an out-out-bounds address, and test for that address....

    My fixed code, with no SIGSEGV Segmentation Fault error:

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

    #include <iostream> int main() {     //defines array with no 20 integer value in any element     //array length (arrLength) defined before array decay     int arr[] = {2, 5, 4, 10, 8, 15, 16, 40};     int arrLength = sizeof(arr) / sizeof(arr[0]);     //integer pointer "found" set as null pointer     int *found = NULL;          //iterating throught every element of array arr     for (int *start = arr; start < (arr + arrLength); ++start)     {         //start pointer deferred to compare against 20 literal         if (*start == 20)             //memory address of start assigned to pointer found             found = start;     }     //after the loop, if the pointer "found" is not equal to the integer after the last of the array     if (found != NULL)         std::cout << *found << '\n';         //then print deference of pointer found     else         std::cout << "integral literal '20' not found in array 'arr'.\n";         //else print that 20 was not found in comparisons     return 0; }

    • nascardriver

      March 6, 2020 at 10:07 am · Reply

      hi!

      Setting `found` to the end (ie. `arr + arrLength`) is not wrong. That's what the standard library does too to indicate that whatever it searched for was not found. The issue in your code was the wrong comparison in line 15, which you already fixed.

      Judging by your code, you know C or you started learning C++ elsewhere. You're writing C++98, doing so will give you a harder time later on. Here are some topics you should catch up on:
      - Brace initialization
      - `std::size`
      - `nullptr`

• Andrei

  February 24, 2020 at 7:27 pm · Reply

  Do we have any reasons to stick asterisk to int instead of begin and end in Solution to Quiz #2?

  1	int* find(int* begin, int* end, int value)

  Shouldn't it follow your previous advice "When declaring a pointer variable, put the asterisk next to the variable name"?
  Thank you!

• fxr

  February 16, 2020 at 9:51 am · Reply

  Hello, Nascardriver driver I don't really understand how std::end works cause on my machine when I tried to use this code end is given some nonsense value why is that and what does std::end do shouldn't it just take the last element of the array-like std::begin dose with the first element or is something in my code messing it up.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  #include <iostream> #include <iterator>     int *find(int* begin, int* end, int value) {        while (*begin != value || begin == end)         ++begin;     if (*begin == value)              return begin;     else         return end;      } int main() {     int arr[]{ 2, 5, 4, 10, 8, 24, 16, 40 };     int* found{ find(std::begin(arr), std::end(arr), 20) };       if (found != std::end(arr))     {         std::cout << *found << '\n';     }       return 0; }

  • nascardriver

    February 17, 2020 at 8:09 am · Reply

    `std::end` returns the element that would be at arr[length(arr)], but it's not a real element, accessing it causes undefined behavior.

    1 2	2, 5, 4, 10, 8, 24, 16, 40, ??? // this is what std::end returns  ^^^

    Your `while`-loop is wrong. If `begin == end` and you increase `begin`, you'll never terminate. It should be

    1	while (begin != end && *begin != value)

    Note also the change of order. If `begin == end` and you access `*begin`, you're invoking undefined behavior.

    You don't need the `if`-statement after that, it doesn't do anything.

    • fxr

      February 18, 2020 at 1:22 pm · Reply

      thank you so much nascardriver I did not understand what std::end did thank you very much for clearing it up.

• kavin

  January 23, 2020 at 8:36 am · Reply

  For quiz 2 i did this.

  1 2 3 4 5 6 7 8 9 10 11

  int* find(int* begin, int* end, int value) {     for (begin; begin < end; ++begin)     {         if (*begin == value)         {             return begin;         }     }     return end; }

  I saw your solution. Why are you initializing begin to pointer p? we already know begin is a pointer right?can't we use begin as a address directly? and can i use begin < end , since we know end is " arr + std::size(arr) " and compare 2 addresses to loop through them?

  • nascardriver

    January 23, 2020 at 8:52 am · Reply

    > Why are you initializing begin to pointer p?
    Modifying arguments makes code harder to understand. Once you modify `begin`, it's name is no longer correct, it's not pointing to the beginning of the data.

    > can i use begin < end Yes, there's nothing wrong with it. Using != is more portable, you'll learn more about it in the lesson about iterators.

    • kavin

      January 23, 2020 at 9:12 am · Reply

      Oh ok, thank you. Now i get it. Since we were using variable values in the called function in previous chapters without initializing them to other variable , i thought i could apply it here. So for pointers the best practice is not modify the parameter and initialize them to another pointer and modify that  ?

      And i have another common doubt for quite sometime.I forgot to ask you in previous chapters. Why do u use "return end; " outside of loop? Can't you put an else and use like this,

      1 2 3 4 5 6 7 8 9 10

      int* find(int* begin, int* end, int value) {     for (int* p{begin}; p != end; ++p)     {         if (*p == value)             return p;         else             return end;     } }

      • nascardriver

        January 23, 2020 at 9:15 am · Reply

        Modifying parameters is never good if it changes the meaning of the variable.
        Your suggested update doesn't work. The function always returns in the first iteration.

        • kavin

          January 23, 2020 at 9:54 am · Reply

          >The function always returns in the first iteration<

          Oh yes ! I couldn't figure out this issue small issue till now :( Thank you @nascardriver.

• Suyash

  January 20, 2020 at 5:23 am · Reply

  Here's the code to my solution...

  1 2 3 4 5 6 7 8 9 10 11

  #include <iostream> #include <iterator>   int* find(int *begin, int *end, int value) {     for (int* ptr{ begin }; ptr != end; ++ptr)         if (*ptr == value)             return ptr;          return end; }

  • nascardriver

    January 20, 2020 at 5:30 am · Reply

    Pretty much exactly the same as the solution, good job!

• chai

  December 31, 2019 at 6:52 am · Reply

  [code]
  std::count_if(name, name + nameLength, isVowel)
  [code]
  What type of functions are compatible with std::count_if? Something similar to bool isVowel(char ), I am guessing that it has to accept a type to be counted and returns a bool and count_if counts the bool returned? .It is also odd and first encounter of a function being passed as argument without ().

  • nascardriver

    December 31, 2019 at 7:01 am · Reply

    The function has to return a `bool` and take an argument of the array element type. We have an array of `char`s, so the function has to accept a char. It could also accept types that can be created from a char, eg. an `int`.
    If we had an array of `std::string`s, the the function would have to accept a `std::string`.

    Algorithms will get more prominent in the tutorials. There will be a short introduction about them once it's clear in which lesson they're first used. It's not too difficult to understand how to use algorithms without knowing how they work, so they're adding them to the tutorials before we explain how they work.

• chai

  December 30, 2019 at 1:26 pm · Reply

  It would be great to have an exercise here.

  • nascardriver

    January 17, 2020 at 6:59 am · Reply

    Thank your for your feedback!

    I added two questions to the lesson to help future readers understanding pointer arithmetic.

• elvis

  December 3, 2019 at 2:24 pm · Reply

  in the example where it sorts through mollie to find how many vowels there are. the for loop has this condition in it ptr < (name + arrayLength) how does it add name and int? I tried printing "name + arrayLength" and i get random garbage. does name and array length convert to pointers when they are being compared to ptr?

  • nascardriver

    December 4, 2019 at 4:11 am · Reply

    Hi Elvis!

    Your question is the main topic of this lesson, I suggest you re-read it.
    `name + arrayLength` returns a pointer that points `arrayLength` bytes after `name`.

    • Elvis

      December 13, 2019 at 8:50 am · Reply

      Had a bit of a brain fart.
      Thank you nascar driver!

• Ged

  November 20, 2019 at 11:36 am · Reply

  Code is missing the <algorithm> library. And why are we using std::size_t, because when I try to run it I get an error and if I change it to an int, it works. Only if I use the static_cast<std::size_t>( ) it works, but why do the extra work? As I understand size_t is an unsigned int which you told to avoid if you can.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  #include <iostream> #include <iterator> // for std::begin and std::end bool isVowel(char ch) {   switch (ch)   {   case 'A':   case 'a':   case 'E':   case 'e':   case 'I':   case 'i':   case 'O':   case 'o':   case 'U':   case 'u':     return true;   default:     return false;   } } int main() {   char name[]{ "Mollie" };   std::size_t numVowels{ std::count_if(std::begin(name), std::end(name), isVowel) };   std::cout << name << " has " << numVowels << " vowels.\n";   return 0; }

  • nascardriver

    November 21, 2019 at 2:43 am · Reply

    > Code is missing the library
    Added.

    > why are we using std::size_t
    I thought `std::count_if` returned an `std::size_t`. It returns a `std::ptrdiff_t` in this case. Code updated to use `auto`.

    > As I understand size_t is an unsigned int which you told to avoid if you can.
    It's an unsigned integer, but not necessarily an unsigned int. If you don't modify an unsigned integer and don't use it for arithmetic, there's nothing that can go wrong. If `std::count_if` returned a `std::size_t`, we would've needed an extra cast when all we want to do is print the result.

    Thanks!

• Ged

  November 20, 2019 at 10:51 am · Reply

  It turns out that when the compiler sees the subscript operator ([]), it actually translates that into a pointer addition and dereference! Generalizing, array[n] is the same as *(array + n), where n is an integer. The subscript operator [] is there both to look nice and for ease of use (so you don’t have to remember the parenthesis).

  Isn't [] used to save a changed value which *() can't do?

  1 2	array[n] = 7; this will work *(array + n) = 7; this shouldn't work?

  • nascardriver

    November 21, 2019 at 2:45 am · Reply

    Indirection (*ptr) returns a reference (covered later). References can be used to modify the value.

• Jack Overby

  October 28, 2019 at 9:48 am · Reply

  I'm trying to loop through and perform a regex check on each character, rather than switch-10 different cases:

  1 2 3 4 5 6 7 8

  for (char *ptr = name; ptr < name + chlen; ++ptr)     {         std::cout << *ptr << "\n";         if (std::regex_match(*ptr, std::regex("[aeiouAEIOU]")))         {             ++numVowels;         }     }

  However, I keep getting the following compiler error message:

  no instance of overloaded function "std::regex_match" matches the argument list

  Any suggestions?

  • nascardriver

    October 29, 2019 at 2:21 am · Reply

    Regex shouldn't be used for this. It has a huge overhead compared to manually solving the task.
    You'll get the best results from using a `switch`. I understand you don't want to do that.
    You can use an `std::set` and `std::count_if` instead.

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

    #include <algorithm> #include <iostream> #include <set> #include <string>   int main(void) {   std::string strTest{ "Hello AJack" };   std::set setVowels{ 'a', 'e', 'i', 'o', 'u',                       'A', 'E', 'I', 'O', 'U' };     // You could add AEIOU to @strVowels automatically.   // std::transform(setVowels.begin(), setVowels.end(),   //                std::inserter(setVowels, setVowels.end()), [](char ch) {   //                  return std::toupper(ch);   //                });     // The [](){} is an anonymous function (Lambda).   auto sVowels{ std::count_if(strTest.begin(), strTest.end(), [&](char ch) {     return (setVowels.count(ch) > 0); // setVowels.contains(ch) since C++20   }) };     std::cout << sVowels << " vowels\n";     return 0; }

    If you really wanted to use regex, which you shouldn't, you could use an `std::sregex_iterator` and `std::distance`. `std::sregex_iterator` iterates over all found matches.

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

    #include <iostream> #include <iterator> #include <regex> #include <string>   int main(void) {   std::string strTest{ "Hello Jack" };   std::regex rxVowels{ "[aeiou]", std::regex::icase };     auto itBegin{     std::sregex_iterator{ strTest.begin(), strTest.end(), rxVowels }   };     std::cout << std::distance(itBegin, std::sregex_iterator{}) << " vowels\n";     return 0; }

• alfonso

  September 26, 2019 at 1:28 am · Reply

  Here the char array name does not decay or std::cout treats it in a special way.

  1 2 3 4 5 6 7 8 9 10 11 12

  #include <iostream>   int main () {     char name [] {"Alberta"};       std::cout << name << '\n';     std::cout << name + 1 << '\n';     std::cout << name + 2 << '\n';     std::cout << name + 3 << '\n';       return 0; }

  And maybe for the same reason, the following code gives me strange results:

  1 2 3 4 5 6 7 8 9 10 11 12 13

  #include <iostream>   int main () {     char ch {'a'};     char *chptr {&ch};       std::cout << chptr << '\n';     std::cout << chptr + 1 << '\n';     std::cout << chptr + 2 << '\n';     std::cout << chptr + 3 << '\n';       return 0; }

  • nascardriver

    September 26, 2019 at 4:05 am · Reply

    std::cout treats it in a special way