9.19 — For-each loops

By Alex on July 31st, 2015 | last modified by nascardriver on April 6th, 2021

In lesson 6.3 -- Arrays and loops, we showed examples where we used a for loop to iterate through each element of an array.

For example:

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

#include <iostream> #include <iterator> // std::size   int main() {     constexpr int scores[]{ 84, 92, 76, 81, 56 };     constexpr int numStudents{ std::size(scores) };       int maxScore{ 0 }; // keep track of our largest score     for (int student{ 0 }; student < numStudents; ++student)     {         if (scores[student] > maxScore)         {             maxScore = scores[student];         }     }     std::cout << "The best score was " << maxScore << '\n';     return 0; }

While for loops provide a convenient and flexible way to iterate through an array, they are also easy to mess up and prone to off-by-one errors.

There’s a simpler and safer type of loop called a for-each loop (also called a range-based for-loop) for cases where we want to iterate through every element in an array (or other list-type structure).

For-each loops

The for-each statement has a syntax that looks like this:

for (element_declaration : array)
   statement;

When this statement is encountered, the loop will iterate through each element in array, assigning the value of the current array element to the variable declared in element_declaration. For best results, element_declaration should have the same type as the array elements, otherwise type conversion will occur.

Let’s take a look at a simple example that uses a for-each loop to print all of the elements in an array named fibonacci:

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

#include <iostream>   int main() {     constexpr int fibonacci[]{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };     for (int number : fibonacci) // iterate over array fibonacci     {        std::cout << number << ' '; // we access the array element for this iteration through variable number     }       std::cout << '\n';       return 0; }

This prints:

0 1 1 2 3 5 8 13 21 34 55 89

Let’s take a closer look at how this works. First, the for loop executes, and variable number is set to the value of the first element, which has value 0. The program executes the statement, which prints 0. Then the for loop executes again, and number is set to the value of the second element, which has value 1. The statement executes again, which prints 1. The for loop continues to iterate through each of the numbers in turn, executing the statement for each one, until there are no elements left in the array to iterate over. At that point, the loop terminates, and the program continues execution (returning 0 to the operating system).

Note that variable number is not an array index. It’s assigned the value of the array element for the current loop iteration.

For each loops and the auto keyword

Because element_declaration should have the same type as the array elements, this is an ideal case in which to use the auto keyword, and let C++ deduce the type of the array elements for us.

Here’s the above example, using auto:

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

#include <iostream>   int main() {     constexpr int fibonacci[]{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };     for (auto number : fibonacci) // type is auto, so number has its type deduced from the fibonacci array     {        std::cout << number << ' ';     }       std::cout << '\n';       return 0; }

For-each loops and references

In the following for-each example, our element declarations are declared by value:

1 2 3 4 5

std::string array[]{ "peter", "likes", "frozen", "yogurt" };     for (auto element : array) // element will be a copy of the current array element     {         std::cout << element << ' ';     }

This means each array element iterated over will be copied into variable element. Copying array elements can be expensive, and most of the time we really just want to refer to the original element. Fortunately, we can use references for this:

1 2 3 4 5

std::string array[]{ "peter", "likes", "frozen", "yogurt" };     for (auto& element: array) // The ampersand makes element a reference to the actual array element, preventing a copy from being made     {         std::cout << element << ' ';     }

In the above example, element will be a reference to the currently iterated array element, avoiding having to make a copy. Also any changes to element will affect the array being iterated over, something not possible if element is a normal variable.

And, of course, it’s a good idea to make your reference const if you’re intending to use it in a read-only fashion:

1 2 3 4 5

std::string array[]{ "peter", "likes", "frozen", "yogurt" };     for (const auto& element: array) // element is a const reference to the currently iterated array element     {         std::cout << element << ' ';     }

Rule

In for-each loops element declarations, if your elements are non-fundamental types, use references or const references for performance reasons.

Rewriting the max scores example using a for-each loop

Here’s the example at the top of the lesson rewritten using a for each loop:

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

#include <iostream> int main() {     constexpr int scores[]{ 84, 92, 76, 81, 56 };     int maxScore{ 0 }; // keep track of our largest score       for (auto score : scores) // iterate over array scores, assigning each value in turn to variable score     {         if (score > maxScore)         {             maxScore = score;         }     }     std::cout << "The best score was " << maxScore << '\n';     return 0; }

Note that in this example, we no longer have to manually subscript the array or get its size. We can access the array element directly through variable score. The array has to have size information. An array that decayed to a pointer cannot be used in a for-each loop.

For-each loops and non-arrays

For-each loops don’t only work with fixed arrays, they work with many kinds of list-like structures, such as vectors (e.g. std::vector), linked lists, trees, and maps. We haven’t covered any of these yet, so don’t worry if you don’t know what these are. Just remember that for each loops provide a flexible and generic way to iterate through more than just arrays.

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

#include <iostream> #include <vector>   int main() {     std::vector fibonacci{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 }; // note use of std::vector here rather than a fixed array     // Before C++17     // std::vector<int> fibonacci{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };       for (auto number : fibonacci)     {         std::cout << number << ' ';     }       std::cout << '\n';       return 0; }

For-each doesn’t work with pointers to an array

In order to iterate through the array, for-each needs to know how big the array is, which means knowing the array size. Because arrays that have decayed into a pointer do not know their size, for-each loops will not work with them!

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

#include <iostream>   int sumArray(const int array[]) // array is a pointer {     int sum{ 0 };       for (auto number : array) // compile error, the size of array isn't known     {         sum += number;     }       return sum;   }   int main() {      constexpr int array[]{ 9, 7, 5, 3, 1 };        std::cout << sumArray(array) << '\n'; // array decays into a pointer here        return 0; }

Similarly, dynamic arrays won’t work with for-each loops for the same reason.

Can I get the index of the current element?

For-each loops do not provide a direct way to get the array index of the current element. This is because many of the structures that for-each loops can be used with (such as linked lists) are not directly indexable!

Since C++20, range-based for-loops can be used with an init-statement just like the init-statement in if-statements. We can use the init-statement to create a manual index counter without polluting the function in which the for-loop is placed.

The init-statement is placed right before the loop variable:

for (init-statement; element_declaration : array)
   statement;

In the following code, we have two arrays which are correlated by index. For example, the student with the name at names[3] has a score of scores[3]. Whenever a student with a new high score is found, we print their name and difference in points to the previous high score.

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

#include <iostream> int main() {     std::string names[]{ "Alex", "Betty", "Caroline", "Dave", "Emily" }; // Names of the students     constexpr int scores[]{ 84, 92, 76, 81, 56 };     int maxScore{ 0 };       for (int i{ 0 }; auto score : scores) // i is the index of the current element     {         if (score > maxScore)         {             std::cout << names[i] << " beat the previous best score of " << maxScore << " by " << (score - maxScore) << " points!\n";             maxScore = score;         }                  ++i;     }     std::cout << "The best score was " << maxScore << '\n';     return 0; }

Output

Alex beat the previous best score of 0 by 84 points!
Betty beat the previous best score of 84 by 8 points!
The best score was 92

The int i{ 0 }; is the init-statement, it only gets executed once when the loop starts. At the end of each iteration, we increment i, similar to a normal for-loop. However, if we were to use continue inside the loop, the ++i would get skipped, leading to unexpected results. If you use continue, you need to make sure that i gets incremented before the continue is encountered.

Before C++20, the index variable i had to be declared outside of the loop, which could lead to name conflicts when we wanted to define another variable named i later in the function.

Conclusion

For-each loops provide a superior syntax for iterating through an array when we need to access all of the array elements in forwards sequential order. It should be preferred over the standard for loop in the cases where it can be used. To prevent making copies of each element, the element declaration should ideally be a reference.

Quiz time

This one should be easy.

Question #1

Declare a fixed array with the following names: Alex, Betty, Caroline, Dave, Emily, Fred, Greg, and Holly. Ask the user to enter a name. Use a for each loop to see if the name the user entered is in the array.

Sample output:

Enter a name: Betty
Betty was found.

Enter a name: Megatron
Megatron was not found.

Hint: Use std::string_view as your array type.

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 30

#include <iostream> #include <string> #include <string_view>   int main() {     constexpr std::string_view names[]{ "Alex", "Betty", "Caroline", "Dave", "Emily", "Fred", "Greg", "Holly" };     std::cout << "Enter a name: ";     std::string username{};     std::cin >> username;       bool found{ false };       for (const auto name : names)     {         if (name == username)         {             found = true;             break;         }     }       if (found)         std::cout << username << " was found.\n";     else         std::cout << username << " was not found.\n";       return 0; }

9.20 -- Void pointers

Index

9.18 -- Member selection with pointers and references

C++ Tutorial |  Print This Post

363 comments to 9.19 — For-each loops

• Andreas Krug

  March 23, 2021 at 11:28 am · Reply

  Small suggestion: In lesson 9.3 -- Arrays and loops  instead of  In lesson 6.3 -- Arrays and loops

• EternalSkid

  March 21, 2021 at 1:40 pm · Reply

  Hello alex and nascardriver, one thing i do not understand about this lesson is why must the array in the quiz be std::string_view? I know that as this is read-only memory in this situation, it is good practice. However, does std::string work in this situation as well? Thanks for the explanation!

  • nascardriver

    March 22, 2021 at 7:54 am · Reply

    Since C++20, it might work if you use `std::string` (No compiler supports `constexpr std::string` yet).
    Before C++20, you'd have to make the array `const` rather than `constexpr`. `std::string` dynamically allocates memory, it cannot run at compile-time.

• kio

  March 10, 2021 at 2:18 pm · Reply

  Hi Alex and NascarDriver,

  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 <string_view> #include <string>     std::string promptUserForName() {     std::cout << "Enter a name: ";     std::string temp;     std::getline(std::cin, temp);     return temp; }   int main() {     constexpr std::string_view arrayNames[]{ "Alex" , "Betty" , "Caroline", "Dave", "Emily", "Fred", "Greg", "Holly" };     std::string nameForSearch{ promptUserForName() };     bool found{ false };     for (const auto& name : arrayNames)     {         if (name == nameForSearch)         {             found = true;             std::cout << nameForSearch << " was found! \n";             break;         }     }     if (!found)     std::cout << nameForSearch << " was not found \n";         std::cin.get();     return 0; }

• Sahil

  February 1, 2021 at 4:16 am · Reply

  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

  #include <iostream> #include <string> #include <string_view>   std::string getName (); //void searchArray (const std::string_view &names);   int main() {     constexpr std::string_view names[] {"Alex", "Betty", "Caroline", "Dave", "Emily", "Fred", "Greg", "Holly"};     bool wasFound {false};     std::string temp {getName()};     for(auto &name: names) {         if(name == temp) {             wasFound = true;             break;         }     }     if (wasFound)         std::cout << temp << " was found.\n";     else         std::cout << temp << " was not found.\n";              return 0; }     //Ask user to enter a name to be searched std::string getName() {     std::cout << "Enter a name to be searched: ";     std::string name{};     std::getline(std::cin, name);          return name; }

  This code works, but if I put lines 11 through line 22 inside the searchArray function I get a couple of errors, I think it has to do with the fact that the array 'names' decays into a pointer. Is there a way to prevent this? I also think that I've made a mistake in my function declaration, is it correct? if not what would be the correct declaration.

  Thanks

  • nascardriver

    February 3, 2021 at 5:48 am · Reply

    Your `searchArray()` takes a reference to a single string. If you want it to accept an array, you need to use `[]` or `*`

    1 2 3

    // These 2 do the same void searchArray(const std::string_view* names); void searchArray(const std::string_view names[]);

    Range-based for-loop don't work with decayed arrays. You can use `std::span` (Not covered on learncpp) to preserve the length.

    1 2 3 4

    void searchArray(std::span<const std::string_view> names) {   // @names can be used as if it were an array }

• Sahil

  February 1, 2021 at 3:38 am · Reply

  In "For-each doesn’t work with pointers to an array"

  You use const on line 3 and constexpr on line 17, I know that const means the variable is constant and constexpr means that the value will be evaluated at compile time, but I still can't wrap my head around when to use which identifier.

  • nascardriver

    February 3, 2021 at 5:45 am · Reply

    If something can be `constexpr` without extra effort, it should be `constexpr`. Parameters cannot be `constexpr`, because the arguments might not be known at compile-time.

• Waldo Lemmer

  January 31, 2021 at 1:05 pm · Reply

  1. Section "For-each loops and references":
  Snippet 2, line 2:
  > `for (auto &element: array)`

  Snippet 3, line 2:
  > `for (const auto &element: array)`

  operator& should be next to auto

  2. Is it fine to have multiple return statements in @main()?

  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

  #include <iostream> #include <string> #include <string_view>   int main() {     constexpr std::string_view names[]     {         "Alex", "Betty", "Caroline", "Dave", "Emily", "Fred", "Greg", "Holly"     };          std::cout << "Enter a name: ";     std::string name{};     std::cin >> name;       for (const auto currentName : names)     {         if (name == currentName)         {             std::cout << currentName << " was found.\n";             return 0;         }     }     std::cout << name << " was not found.\n";       return 0; }

  P.S. I love completing the questions, I wish there were more!

  • nascardriver

    February 3, 2021 at 5:42 am · Reply

    1. Fixed, thanks!

    2. You can, but it's an indicator that you should refactor the function into several functions. The loop can be moved into a function that returns a `bool` indicating whether or not the element was found. You can use `std::span` to be able to use a range-based for-loop in that function.

    • Waldo Lemmer

      February 3, 2021 at 5:44 am · Reply

      Alright, thanks!

• Berrie

  January 30, 2021 at 11:25 am · Reply

  I've been trying to make a function that takes in the string array and the inputname but I can get it to work. Here's my 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 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

  #include <iostream> #include <string> // for std::string, std::string_view and std::size   /* * Declare a fixed array with the following names: * Alex, Betty, Caroline, Dave, Emily, Fred, Greg, and Holly. * Ask the user to enter a name. Use a for each loop to see if the name the * user entered is in the array. * * Sample output: * * Enter a name: Betty * Betty was found. * * Enter a name: Megatron * Megatron was not found. * */   std::string getName() {     std::cout << "Enter a name: ";     std::string name{};     std::getline(std::cin, name);     return name; }   bool findNameInList(std::string_view (&names)[], std::string inputName) {     for (const auto name : names)     {         if (name == inputName)         {             return true;         }     }     return false; }   int main() {     constexpr std::string_view names[]{"Alex", "Betty", "Caroline", "Dave", "Emily", "Fred", "Greg", "Holly"};     auto length{std::size(names)};     auto inputName{getName()};       bool found{findNameInList(names[], inputName)};       if (found)         std::cout << inputName << " was found.\n";     else         std::cout << inputName << " was not found.\n";       return 0; }

  Visual studio code shows the following problem:

  a range-based 'for' statement cannot operate on an array of unknown size or incomplete type "std::__1::string_view []"

  So the for each loop doesn't know the size of the array. Is there a way to pass the length through to the function? Section 9.16 shows an example where the array length is fill into the function argument:

  [code]
  void printElements(int (&arr)[4])
  [\code]

  I've tried this but it doesn't work either.

  • Person

    January 30, 2021 at 3:41 pm · Reply

    I hope this helps.

    line 45> it should just be names, not names[] (the subscript operator without a value is equivalent to *(names + ))
    > names is a const std::string_view[8], so to pass it as a reference findNameInList() should look like this:

    1 2	//note the use of const, since names is a constexpr, and the 8 in the brackets to denote the length of names bool findNameInList(const std::string_view (&names)[8], std::string inputName)

    • Berrie

      January 31, 2021 at 1:21 am · Reply

      Thank you! That worked.
      Although it is annoying you have to manually keep track of the name of the list now. Is there a way to get around this or to pass it into the function as an argument? Without reverting back to a normal for loop because that would beat the purpose.

      • nascardriver

        January 31, 2021 at 3:28 am · Reply

        Have a look at `std::span`

• J34NP3T3R

  January 17, 2021 at 6:47 am · Reply

  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

  #include <iostream> #include <iterator> // for std::size() #include <string>   // for getline   int main() {     std::string_view names[]{ "Alex", "Betty", "Caroline", "Dave", "Emily", "Fred", "Greg", "Holly" };              std::cout << "Enter a name :";     std::string yourname{};     std::getline(std::cin, yourname);       for (auto &curName : names)     {         if (curName == yourname)         {             std::cout << yourname << " was found";             return 0;         }     }       std::cout << yourname << " was NOT found";       return 0; }

• kio

  January 11, 2021 at 1:35 pm · Reply

  Is this acceptable Alex and Nascardriver.

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

  int main() {     constexpr std::string_view names[]{"Alex","Betty","Caroline","Dave","Emily","Fred","Greg","Holly"};       std::cout << "Enter a name: ";     std::string nameFromUser{};     std::getline(std::cin, nameFromUser);         for (const auto& name : names)     {         if (nameFromUser == name)         {             std::cout << name << " was found.\n";             // return 0 and exit from main             return 0;         }       }         std::cout << nameFromUser << " was not found.\n";       return 0; }

  And question for you guys. In your solution in line 21, shouldn't we use const and reference point? We're just getting the name from the array, so we should put const at least. Reference point will not make sanse, because we're using std::string_view, and it's not taking the copy, right?

  Q:
  As you said we can use for each loop, expect for accessing the dynamically allocated arrays. Should we use for loop for those?

  • nascardriver

    January 12, 2021 at 7:56 am · Reply

    I've added the `const`, thanks for pointing it out! The reference is not necessary, because `std::string_view` is cheap to copy.

    For decayed arrays, use a regular for-loop

• Stevie B

  December 27, 2020 at 5:57 pm · Reply

  To create an index pre C++20, can you create an outer block to limit the scope and prevent naming collisions?
  The only downside I can think of is you can't use the data from a previously declared variable, with the same name as the index identifier in the loop, as the ident will be name shadowed.
  Is there any other danger I am missing by doing this?

  PS. Been going through these tutorials for a while but first time poster, they are awesome, good job.

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

  int main() {     int numbers[]{0,1,2,3,5};     std::string names[]{ "Alex", "Betty", "Caroline", "Dave", "Emily" };     int i{12};     std::cout << i << '\n';     // Prints i as variable(12)               {         // i is name-shadowed here and enters scope as index ident         int i{0};     for (auto &elements : numbers)         {             std::cout << names[i] << ": " << elements << '\n';             ++i;         }     }   // i dies here as an index ident and reverts back to a variable named i       i = 11;     std::cout << i << '\n';     // Prints i as variable(11)       return 0; }

  • nascardriver

    December 28, 2020 at 4:16 am · Reply

    Hi!

    The shadow in your example is fine, for-loops with init-statements allow the same shadow.
    There's another possibility to shadow `i`, which isn't allowed when an init-statement is used

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

    #include <iostream>   int main() {   // With an init-statement   for (int i{ 0 }; const auto x : {1, 2, 3}) {     int i{ 123 }; // This is illegal, @i already exists     std::cout << i++ << ": " << x << '\n';   }     // With a manual scope   {     int i{0};     for (const auto x : {1, 2, 3}) {       int i{ 123 }; // This is legal       std::cout << i++ << ": " << x << '\n';     }   } }

• sumguy1

  December 10, 2020 at 10:19 pm · Reply

  Very first line,
  constexpr std::string_view names[]{ "Alex", "Betty", "Caroline", "Dave", "Emily", "Fred", "Greg", "Holly" };

  I run into the compiler error:

  "Constexpr variable 'names' must be initialized by a constant expression"

  What's going on here?

• MG

  November 24, 2020 at 10:50 pm · Reply

  In the above example, element will be a reference to the currently iterated array element, avoiding having to make a copy. Also any changes to element will affect the array being iterated over, something not possible if element is a normal variable.

  Hello. I can’t understand the second sentence. Could you give some examples or any help?

  • nascardriver

    November 25, 2020 at 6:49 am · Reply

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

    std::string array[]{ "peter", "likes", "frozen", "yogurt" }; for (auto &element : array) // The ampersand makes element a reference to the actual array element, preventing a copy from being made {   element = "banana"; } // All elements are now "banana" for (auto element : array) {   // @element is a copy of each element, it's not the original element.   element = "mango";   // @element is now "mango", but the element in @array still is "banana" } // All elements are still "banana"

    • MG

      December 2, 2020 at 11:05 pm · Reply

      I was mistaken about the concept of reference but now it’s clear. Thank you so much!

• Chaitanya Jadhav

  November 24, 2020 at 8:08 am · Reply

  for each doesn't work in a function for array which is passed as parameter

• ali imanzadeh

  November 21, 2020 at 4:17 am · Reply

  when i put init_statement an error occurs on different compilers why?

  • nascardriver

    November 21, 2020 at 6:27 am · Reply

    The init-statement is only available since C++20. You need to use an up-to-date compiler and enable C++20 support.

• yeokaiwei

  November 18, 2020 at 1:06 pm · Reply

  There is a Warning that comes with the Quiz Solution.

  E0169    expected a declaration    for line 49
  E0169    expected a declaration    for line 50

  Severity    Code    Description    Project    File    Line    Suppression State
  Error (active)    E0169    expected a declaration    Chapter6.12aForEachLoop    C:\Users\user\source\repos\Chapter6.12aForEachLoop\Chapter6.12aForEachLoop\Chapter6.12aForEachLoop.cpp    49

  • nascardriver

    November 19, 2020 at 8:22 am · Reply

    The solution doesn't have that many lines and I can't reproduce this warning. Can you try again with just the solution and no additional code?

    • yeokaiwei

      November 19, 2020 at 11:17 am · Reply

      Solved. No more errors.

• yeokaiwei

  November 18, 2020 at 12:46 pm · Reply

  My first try.
  I changed it to the solution later.

  I did not get the answer, only Alex2592 for some reason.

  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

  #include <iostream> #include <string> #include <string_view>   int main() {     //Initialize the name array was incorrect.     //I did not use constexpr as it was prone to crashing     //I used namearray for easier naming     std::string_view namearray[]     { "Alex", "Betty", "Caroline", "Dave", "Emily", "Fred", "Greg","Holly" };          //Ask the user for a name had no issue     std::string username{};     std::cout << "Enter a name: " << '\n';     std::cin >> username;       //Here, I didn't use a bool.     //This is the weird part. I get "Alex was not found2592"     for (auto name : namearray)     {         if (name == username)             std::cout << username << " was found" << '\n ';         else         {             std::cout << username << " was not found" << '\n ';             break;         }     }       std::cout << '\n';       return 0; }

  • nascardriver

    November 19, 2020 at 8:20 am · Reply

    Single quotation marks are for single characters. '\n ' are 2 characters (Line feed and space).
    Your search isn't working due to a common thinking error, give it another try once you fixed your character.

    • yeokaiwei

      November 19, 2020 at 11:16 am · Reply

      Oh, Line 23.

      I actually deleted my shitty code.

      Thanks.