6.3 — Local variables

By Alex on March 23rd, 2015 | last modified by nascardriver on December 7th, 2020

In lesson 2.4 -- Introduction to local scope, we introduced local variables, which are variables that are defined inside a function (including function parameters).

It turns out that C++ actually doesn’t have a single attribute that defines a variable as being a local variable. Instead, local variables have several different properties that help differentiate how local variables behave from other kinds of (non-local) variables. We’ll explore these properties in this and upcoming lessons, as well as a few other local variable related topics of note.

Local variables have block scope

An identifier’s scope determines where an identifier can be accessed within the source code. Scope is a compile-time property.

Local variables have block scope, which means they are in scope from their point of definition to the end of the block they are defined within.

1 2 3 4 5 6 7

int main() {     int i { 5 }; // i enters scope here     double d { 4.0 }; // d enters scope here       return 0; } // i and d go out of scope here

Although function parameters are not defined inside the function body, for typical functions they can be considered to be part of the scope of the function body block.

1 2 3 4 5 6 7

int max(int x, int y) // x and y enter scope here {     // assign the greater of x or y to max     int max{ (x > y) ? x : y }; // max enters scope here       return max; } // x, y, and max leave scope here

The exception case is for function-level exception handling (which we cover in lesson 20.7 -- Function try blocks).

All variable names within a scope must be unique

Variable names must be unique within a given scope, otherwise any reference to the name will be ambiguous. Consider the following program:

1 2 3 4 5 6 7 8 9

void someFunction(int x) {     int x{}; // compilation failure due to name collision with function parameter }   int main() {     return 0; }

The above program doesn’t compile because the variable x defined inside the function body and the function parameter x have the same name and both are in the same block scope.

Local variables have automatic storage duration

A variable’s storage duration (usually just called duration) determines what rules govern when and how a variable will be created and destroyed. In most cases, a variable’s storage duration directly determines its lifetime.

For example, local variables have automatic storage duration, which means they are created at the point of definition and destroyed at the end of the block they are defined in. For example:

1 2 3 4 5 6 7

int main() {     int i { 5 }; // i created and initialized here     double d { 4.0 }; // d created and initialized here       return 0; } // i and d are destroyed here

For this reason, local variables are sometimes called automatic variables.

Local variables in nested blocks

Local variables can be defined inside nested blocks. This works identically to local variables in function body blocks:

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

int main() // outer block {     int x { 5 }; // x enters scope and is created here       { // nested block         int y { 7 }; // y enters scope and is created here     } // y goes out of scope and is destroyed here       // y can not be used here because it is out of scope in this block       return 0; } // x goes out of scope and is destroyed here

In the above example, variable y is defined inside a nested block. Its scope is limited from its point of definition to the end of the nested block, and its lifetime is the same. Because the scope of variable y is limited to the inner block in which it is defined, it’s not accessible anywhere in the outer block.

Note that nested blocks are considered part of the scope of the outer block in which they are defined. Consequently, variables defined in the outer block can be seen inside a nested block:

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

#include <iostream>   int main() { // outer block       int x { 5 }; // x enters scope and is created here       { // nested block         int y { 7 }; // y enters scope and is created here           // x and y are both in scope here         std::cout << x << " + " << y << " = " << x + y << '\n';     } // y goes out of scope and is destroyed here       // y can not be used here because it is out of scope in this block       return 0; } // x goes out of scope and is destroyed here

Local variables have no linkage

Identifiers have another property named linkage. An identifier’s linkage determines whether other declarations of that name refer to the same object or not.

Local variables have no linkage, which means that each declaration refers to a unique object. For example:

1 2 3 4 5 6 7 8 9 10

int main() {     int x { 2 }; // local variable, no linkage       {         int x { 3 }; // this identifier x refers to a different object than the previous x     }       return 0; }

Scope and linkage may seem somewhat similar. However, scope defines where a single declaration can be seen and used. Linkage defines whether multiple declarations refer to the same object or not.

Linkage isn’t very interesting in the context of local variables, but we’ll talk about it more in the next few lessons.

Variables should be defined in the most limited scope

If a variable is only used within a nested block, it should be defined inside that nested block:

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

#include <iostream>   int main() {     // do not define y here       {         // y is only used inside this block, so define it here         int y { 5 };         std::cout << y << '\n';     }       // otherwise y could still be used here, where it's not needed       return 0; }

By limiting the scope of a variable, you reduce the complexity of the program because the number of active variables is reduced. Further, it makes it easier to see where variables are used (or aren’t used). A variable defined inside a block can only be used within that block (or nested blocks). This can make the program easier to understand.

If a variable is needed in an outer block, it needs to be declared in the outer block:

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

#include <iostream>   int main() {     int y { 5 }; // we're declaring y here because we need it in this outer block later       {         int x{};         std::cin >> x;           // if we declared y here, immediately before its actual first use...         if (x == 4)             y = 4;     } // ... it would be destroyed here       std::cout << y; // and we need y to exist here       return 0; }

The above example shows one of the rare cases where you may need to declare a variable well before its first use.

New developers sometimes wonder whether it’s worth creating a nested block just to intentionally limit a variable’s scope (and force it to go out of scope / be destroyed early). Doing so makes that variable simpler, but the overall function becomes longer and more complex as a result. The tradeoff generally isn’t worth it. If creating a nested block seems useful to intentionally limit the scope of a chunk of code, that code might be better to put in a separate function instead.

Best practice

Define variables in the most limited existing scope. Avoid creating new blocks whose only purpose is to limit the scope of variables.

Quiz time

Question #1

Write a program that asks the user to enter two integers, one named smaller, the other named larger. If the user enters a smaller value for the second integer, use a block and a temporary variable to swap the smaller and larger values. Then print the values of the smaller and larger variables. Add comments to your code indicating where each variable dies. Note: When you print the values, smaller should hold the smaller input and larger the larger input, no matter which order they were entered in.

The program output should match the following:

Enter an integer: 4
Enter a larger integer: 2
Swapping the values
The smaller value is 2
The larger value is 4

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

#include <iostream>   int main() {     std::cout << "Enter an integer: ";     int smaller{};     std::cin >> smaller;       std::cout << "Enter a larger integer: ";     int larger{};     std::cin >> larger;       // if user did it wrong     if (smaller > larger)     {         // swap values of smaller and larger         std::cout << "Swapping the values\n";           int temp{ larger };         larger = smaller;         smaller = temp;     } // temp dies here       std::cout << "The smaller value is: " << smaller << '\n';     std::cout << "The larger value is: " << larger << '\n';       return 0; } // smaller and larger die here

Question #2

What’s the difference between a variable’s scope, duration, and lifetime? By default, what kind of scope and duration do local variables have (and what do those mean)?

Show Solution

A variable’s scope determines where the variable is accessible. Duration defines the rules that govern when a variable is created and destroyed. A variable’s lifetime is the actual time between its creation and destruction.

Local variables have block scope, which means they can be accessed inside the block in which they are defined.

Local variables have automatic duration, which means they are created at the point of definition, and destroyed at the end of the block in which they are defined.

6.4 -- Introduction to global variables

Index

6.2 -- User-defined namespaces

C++ Tutorial |  Print This Post

252 comments to 6.3 — Local variables

• mark brain

  February 6, 2021 at 12:14 pm · Reply

  My code using functions:

  #include <iostream>

  void printResult(int smaller, int larger)
  {
      std::cout << "The smaller value is " << smaller << '\n';
      std::cout << "The larger value is " << larger;
  }

  void checkIntegers(int smaller, int larger)
  {
      int temp{};
      if (smaller > larger)
      {
          std::cout << "Swapping the values" << '\n';
          temp = smaller;
          smaller = larger;
          larger = temp;
      }
      printResult(smaller, larger);
  }
  void getInput()
  {
      int smaller{};
      int larger{};
      std::cout << "Enter an integer: ";
      std::cin >> smaller;
      std::cout << "enter a larger integer: ";
      std::cin >> larger;
      checkIntegers(smaller, larger);
  }
  int main()
  {
      getInput();
      return 0;
  }

• joshie

  January 22, 2021 at 4:34 am · Reply

  How's 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 27 28

  #include <iostream>   int main() {       std::cout << "Enter an integer\n";     int smaller{};     std::cin >> smaller;       std::cout << "Enter a larger integer\n";     int larger{};     std::cin >> larger;       {         if (larger < smaller)         {             std::cout << "Swapping the values\n";             int larger{smaller}; // local variable larger comes into scope             int smaller{larger}; // local variable smaller comes into scope               std::cout << "The smaller value is: " << larger << '\n'; // both still in scope             std::cout << "The larger value is: " << smaller << '\n'; // both still in scope         }         else             std::cout << "Your second integer was larger than your first!"; // both still in scope       } //local variables destroyed   }

  • Bob

    January 26, 2021 at 1:02 pm · Reply

    Did you try it?

    If a user enters 3 for larger and 5 for smaller, then when you get to your swap at best the "new" definition of larger will make that 5, but then in the next line smaller gets defined as larger, so it would be 5 as well.
    And then the whole swap becomes pointless, since it's all in the if (larger<smaller) block you cout larger as the smaller value and smaller as the larger value.

    • joshie

      January 26, 2021 at 4:24 pm · Reply

      Thanks for the prompt reply!

      That completely blew over my head, I didn't consider that haha.

      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

      #include <iostream>     int main(){       std::cout << "Please enter an integer\n";     int smaller{};     std::cin >> smaller;       std::cout << "Please enter a larger integer";     int larger{};     std::cin >> larger;       if (larger < smaller)     {         std::cout << "Swapping the values\n";         int temporary{larger};         larger = smaller;         smaller = temporary;         std::cout << "The smaller value is " << smaller << '\n';         std::cout << "The larger value is " << larger;     }       else     {         std::cout << "The smaller value is " << smaller << "\n";         std::cout << "The larger value is " << larger;     }       return 0; }

      Is this better?

      • joshie

        January 26, 2021 at 4:25 pm · Reply

        Ignore the "\n" on line 26 it's suppose to be in single quotes.

      • nascardriver

        January 27, 2021 at 6:40 am · Reply

        Line 20-21 and 26-27 are unconditional, they should be outside of your `if`/`else`.

        • joshie

          January 27, 2021 at 7:34 am · Reply

          Got it, thanks nascar.

          Also another quick question, what are the differences between const & constexpr, and which should I favour more?

        • joshie

          January 27, 2021 at 7:46 am · Reply

          Never mind, just went back to 4.13, its clear now thanks!

• nav

  January 21, 2021 at 4:03 pm · 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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

  // swap.cpp file   #include <iostream> #include "swap.h"     int main() {      namespace change = swap;      change::swapp::dosomething(); }     // swap.h file     #ifndef SWAP_H #define SWAP_H int count{ 0 };   namespace swap      {     namespace getNumber     {         int dosomething()         {                          if (count)                  std::cout << "Enter an smaller integer :";             else                  std::cout << "Enter a  larger  integer :";                          int a{ };             std::cin >> a;             count += 1;             return a;           }     }          namespace swapp         {           int dosomething()                    {                                  int a{ getNumber::dosomething() };             int b{ getNumber::dosomething() };             std::cout << "Swapping the values\n";             int max{};             int min{};             if (a == b) {                 std::cout << "Both numbers are equal then! " << a << " = " << b << '\n';                 return 0;             }                                  min = ((a < b) ? a : b );                     std::cout << "The smaller value is : " << min<<'\n';                     max = ((a > b) ? a : b);                     std::cout << "The larger  value is : "  << max<<'\n';                                                                        return 0 ;     }         }     }   #endif // !MATH

  • Bob

    January 26, 2021 at 1:15 pm · Reply

    You realize that doesn't actually swap any values, you're just determining which of two numbers is larger or smaller.

    Let alone the convoluted use of the count variable.

• Cristopher Klingensmith

  December 31, 2020 at 8:15 am · Reply

  For question one I did what it asked successfully but my code for swapping the numbers looks a lot different.
  Here's all my code

  #include <iostream>

  int main()
  {
      std::cout << "Please enter an integer: ";
      int smaller{};
      std::cin >> smaller;

      std::cout << "Please enter another integer: ";
      int larger{};
      std::cin >> larger;

      if (smaller > larger)
      {
          smaller -= larger;// assuming smaller = 15 larger = 5, now smaller = 10
          larger += smaller;// smaller = 10 larger = 5, now larger = 15
          smaller = (larger - smaller);//smaller = 10 larger = 15, now smaller = 5
          std::cout << '\n' << "The smaller value is " << smaller << '\n';
          std::cout << "The Larger value is " << larger << '\n';
      }
      else
      {
          std::cout << '\n' << "The smaller value is " << smaller << '\n';
          std::cout << "The Larger value is " << larger << '\n';
      }

      return 0;
  }// larger and smaller die here

  • TomCruise

    January 8, 2021 at 12:53 pm · Reply

    You are actually making the code harder yourself operator - and + are unnecessary in this case. But you made it yourself which is great. Just do simplify your code next time so you can understand it better and others too.

• J34NP3T3R

  December 27, 2020 at 10:09 pm · Reply

  QUESTIONS : "Local variables have no linkage"

  int main()
  {
      int x { 2 }; // local variable, no linkage

      {
          int x { 3 }; // this identifier x refers to a different object than the previous x

          // 1.) Does this mean the previous x is still "2" outside of this block and whatever changes we make to x here only applies to the x here ?
          // 2.) we can no longer reference the previous x here ? because we defined a new x to be used here.
      }

      return 0;
  }

  • nascardriver

    December 28, 2020 at 4:22 am · Reply

    Your inner `x` _shadows_ the outer `x`. They're different variables and the outer `x` is inaccessible in the inner scope.

• Wake

  December 24, 2020 at 9:40 am · Reply

  I naturally took Question 1 to the next level here thanks to this book! I love how chronological everything is! Topics build on themselves very well. I could move this function to a separate .cpp file to clean up the main.cpp and add a .h file to declare the "printResult" function I suppose.  

  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

  #include <iostream>                                                  // Include <iostream> C++ Library   void printResult(int x, int y)                                     // Create a function that doesn't return a value back to the main function named "printResult" with 2 integer parameters named "x" & "y". {     if (x < y)                                                    // If x < y, do the following...     {                                                            // Don't forget the "curly brackets" with "if" statements!         std::cout << "The smaller value is: " << x << '\n';     // Display to the terminal output "The smaller value is: ", then display "x", then create a new line.         std::cout << "The larger value is: " << y << '\n';     // Display to the terminal output "The lager value is: ", then display "y", then create a new line.     }     else if (x > y)                                           // Else, If x > y, do the following...     {                                                        // Don't forget the "curly brackets" with "if" statements!         std::cout << "Swapping the values...\n";            // Display to the terminal output "Swapping the values... ", then create a new line.         std::cout << "The smaller value is: " << y << '\n';// Display to the terminal output "The smaller value is: ", then display "y", then create a new line.         std::cout << "The larger value is: " << x << '\n';// Display to the terminal output "The lager value is: ", then display "x", then create a new line.     }     else if (x = y)                                      // Else, If x = y, do the following...     {     std::cout << "You entered the same number... \n";  // Display to the terminal output "You entered the same number... \n", then create a new line.     }                                                       // "x" and "y" of the "printResult" function dies here. }   int main()                                           // The main program function.                             {     std::cout << "Enter an integer: ";              // Display to the terminal output "Enter an integer: ".     int x{};                                       // Create and initialize an integer named "x" to zero.     std::cin >> x;                                // Have the user enter a value for "x".       std::cout << "Enter a larger integer: ";    // Display to the terminal output "Enter a larger integer: ".     int y{};                                   // Create and initialize an integer named "y" to zero.     std::cin >> y;                            // Have the user enter a value for "y".          printResult(x, y);                       // Run the "printResult" function with "x"and "y" as the parameter inputs.          return 0;                               // Return zero and end the program.                                              // "x" and "y" of the "main" function dies here. }

• Chayim

  December 22, 2020 at 11:16 pm · Reply

  1 2 3

  int temp{ larger };         larger = smaller;         smaller = temp;

  How is smaller swapped to be smaller by =temp ? How does 'smaller = temp'  work? temp is not smaller (the original smaller because it’s swapped to larger the original smaller) it’s larger.

  • bob

    January 26, 2021 at 1:21 pm · Reply

    Let's say that the use inputs 7 for smaller, and 2 for larger.  The swap is only called if the number entered for smaller is larger

    Temp is a new variable which holds the original value of larger, therefore Temp = 2
    We now set larger to the value that was entered as smaller, so larger =7
    We can now set smaller to the original value of larger, which was held by Temp - smaller =2

    The values of the variables have now been swapped.

• Waldo Lemmer

  December 6, 2020 at 1:01 pm · Reply

  Thanks for the great lesson! Just one correction:

  Second code snippet, line 7:

  1	} // x, y, and max leave scope here here

  The last "here" should be removed.

  P.S. I think I want to stop reading comments. I've spent an hour and a half on this lesson, most of which is spent going through page 4's comments :(

• bool_1E

  November 21, 2020 at 12:30 am · Reply

  Q.1

  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<cstdlib> #include<iostream>   int main() {     std::cout << "Enter an integer:";     int smaller{};     std::cin >> smaller;       std::cout << "Enter a larger integer:";     int larger{};     std::cin >> larger;       if (smaller > larger)     {         int swap{ larger };         std::cout << "Swapping the values\n";         larger = smaller;         smaller = swap;     }//swap destroyed here       std::cout << "The smallest value is:" << smaller << '\n';     std::cout << "The larger value is:" <<   larger << '\n';                  return EXIT_SUCCESS; }//smaller and larger  destroyed here

• yeokaiwei

  November 7, 2020 at 12:00 pm · Reply

  Just some weird feedback.
  Since {} highlights a block, initializing a variable int {7}; seems to suggest that 7 dies within its {}.

  • nascardriver

    November 8, 2020 at 2:38 am · Reply

    You'll have to get used to that. List initialization isn't something we made up or can change, it's a language feature and should be used.

    • yeokaiwei

      November 9, 2020 at 10:18 am · Reply

      I'll just accept it as a self-contradictory syntax.

• Hali

  October 19, 2020 at 3:19 pm · Reply

  This is my take on question one, i feel like mine is unnecessary long compare to your solution but my focus point is that i want to keep the main function clean which i feel like i have achieved that goal.

  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

  #include <iostream>   int inputSmaller(); int inputLarger(); void valueDifference(int numOne, int numTwo);   int main(){        int smaller{inputSmaller()};     int larger{inputLarger()};          valueDifference(smaller, larger);                 std::cout << "\n\n\n\n";     return 0; }   //THIS FUNCTION ASK USER FOR SMALL NUMBER int inputSmaller() {     std::cout << "Enter an integer: ";     int smaller{};     std::cin >> smaller;          return smaller; }   //THIS FUNCTION ASK USER FOR A BIGGER NUMBER int inputLarger() {     std::cout << "Enter a larger integer: ";     int larger{};     std::cin >> larger;          return larger; }   //THIS FUNCTION CALCULATE IF THE INPUT FROM LARGER IS SMALLER THAN SMALL void valueDifference(int numOne, int numTwo) {     if(numOne > numTwo)     {         int temp{numTwo};         numTwo = numOne;         numOne = temp;     }     std::cout << "The smaller number is " << numOne << "\n";     std::cout << "The larger number is " << numTwo << "\n";      }

  • nascardriver

    October 20, 2020 at 8:11 am · Reply

    - "\n" is a string (expensive), '\n' is a character (cheap)
    - Line 23-26 and 33-36 are identical, you can move them into a separate function to avoid code duplication.

    Otherwise good job :)

• Chris Alexander

  September 15, 2020 at 1:42 pm · Reply

  How is 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 27 28 29 30

  #include <iostream>   int main() {     // Tells the user to enter an integer     std::cout << "Enter an integer: ";     int smaller{};     std::cin >> smaller;       // Tells the user to enter a larger value     std::cout << "Enter a larger value: ";     int larger{};     std::cin >> larger;       // If smaller is a bigger value then larger they swap places     if (smaller > larger)     {         std::cout << "Swapping the values" << '\n';                  int temp{ smaller };         smaller = larger;         larger = temp;     }       // This prints out text     std::cout << "The smaller value is: " << smaller << '\n';     std::cout << "The larger value is: " << larger << '\n';       return 0; }

  • nascardriver

    September 26, 2020 at 3:28 am · Reply

    Good :)

• 3li Mot 3alim

  August 31, 2020 at 7:21 am · Reply

  How can multiple declarations refer to the same object?

• Yousuf

  August 29, 2020 at 7:24 am · Reply

  I expected to read some lines about one definition rule or ODR in the light of local variables.

  • cae

    September 2, 2020 at 10:46 am · Reply

    ODR was covered in chapter 2.7 already.

• Uy Ph

  August 25, 2020 at 4:57 pm · Reply

  Hi. I'm really confused on the linkage versus scope part. According to this code:

  1 2 3 4 5 6 7 8 9

  int main() {     int x { 2 }; // local variable, no linkage     {         int x { 3 }; // this identifier x refers to a different object than the previous x     }     return 0;

  the two x's refer to different objects, but are they not in the same scope, considering x{2} can also be seen in the nested block? This should make them two collided identifier names though?

  • nascardriver

    August 26, 2020 at 7:18 am · Reply

    The inner `x` _shadows_ the outer `x`, making it inaccessible

• Tony

  July 24, 2020 at 8:06 am · Reply

  Question 2, almost there!

  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 getUserInput() {     std::cout << "Enter an integer: ";     int x{};     std::cin >> x;     return x; }   int main() {     int smaller{ getUserInput() }; // assume smaller = 4     int larger{ getUserInput() };  // assume larger = 2       if (smaller > larger)     {         int temp{ smaller }; // temp = 4 (smaller)         smaller = larger;//smaller becomes 2         larger = temp;   // larger becomes 4         std::cout << "Larger: " << larger << '\n' << "Smaller: " << smaller;     }       else         std::cout << "Larger: " << larger << '\n' << "Smaller: " << smaller;       return 0; }

  btw, these questions are so nice! Make me want to learn more every time :P

  • nascardriver

    July 26, 2020 at 1:12 am · Reply

    The point of swapping the integers is that you don't need to repeat line 19/23. This line is unconditional and should be moved out of the if-statement.

• Tony

  July 24, 2020 at 7:48 am · Reply

  Hi again!
  Why does this work:

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

  1 2 3 4 5 6 7 8 9 10 int main() {     int x { 2 }; // local variable, no linkage     {         int x { 3 }; // this identifier x refers to a different object than the previous x     }     return 0; }

  And this one not?

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

  1 2 3 4 5 6 7 8 9 10 int main() {     int x { 2 }; // local variable, no linkage     int x { 3 }; // this identifier x refers to a different object than the previous x     return 0; }

  This one ^ is considered double definition, but in the first example it's not. Is that because of blocks? What's the reason? Thank you :)

  • nascardriver

    July 26, 2020 at 1:11 am · Reply

    It's because the second `x` of the first example is in a block. The second `x` _shadows_ the first `x`. We go over this later in this chapter.

    • Tony

      July 26, 2020 at 2:21 am · Reply

      Saw it later. Sorry for not updating.  Thank you :)

• Max

  June 27, 2020 at 2:34 am · Reply

  Hello, I'm really stuck on the fact that local variables don't have linkage, especially with your example:

  1 2 3 4 5 6 7 8 9 10

  int main() {     int x { 2 }; // local variable, no linkage     {         int x { 3 }; // this identifier x refers to a different object than the previous x     }     return 0; }

  Is it because when we declare x here it also defines it and so both local vars can never refer to the same object?

  and are there any other reasons?

• Math

  June 15, 2020 at 2:50 am · Reply

  Hello!
  This is my code for the first question but I noticed that it prints twice like this:
  Enter an integer: 1
  Enter a larger integer: 0
  Swapping the values
  The smaller value is 0
  The larger value is 1
  The smaller value is 0
  The larger value is 1

  This is 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

  #include <iostream>   int main() {     std::cout << "Enter an integer: ";     int smaller{}; // smaller enters scope here     std::cin >> smaller;       std::cout << "Enter a larger integer: ";     int larger{}; // larger enters scope here     std::cin >> larger;       if (smaller > larger)     {         std::cout << "Swapping the values\n";         int swap{ larger }; // swap enters scope here         larger = smaller;         smaller = swap;         std::cout << "The smaller value is " << smaller << '\n';         std::cout << "The larger value is " << larger << '\n';     } // swap is destroyed here          std::cout << "The smaller value is " << smaller << '\n';     std::cout << "The larger value is " << larger << '\n';          return 0; }//smaller and larger are destroyed here

  However, I noticed that when I run the solution you provided to the question it runs fine.
  I added an 'else' statement so the rest of my code looks like this

  1 2 3 4 5

  else     {         std::cout << "The smaller value is " << smaller << '\n';         std::cout << "The larger value is " << larger << '\n';     }

  It then worked as expected, only printing once.

  I couldn't figure out why my code needed an 'else' statement and yours didn't, can you guys please explain?

  • nascardriver

    June 16, 2020 at 4:50 am · Reply

    You're printing once in line 19,20 and then again in line 23,24.
    Line 23,24 aren't affected by your if-statement. See lesson 4.10.
    When you add an `else`, line 23,24 will only execute if the condition in line 13 was `false`.

    Line 19,20 and 23,24 are identical. If you repeat code, you're doing something wrong. You can remove line 19,20, because you're already printing in line 23,24. The printing of the values is unconditional.

    • Math

      June 17, 2020 at 9:15 am · Reply

      Ooooh my bad sorry, I haven't realized that this was the difference I thought both codes were identical.

    • Math

      June 17, 2020 at 9:32 am · Reply

      I am sorry one more question, I know it is best practice to separate your code into functions. So here would it have been better if I declared a function to get the integer value from the user or is it unnecessary in this case since we're only asking the user to enter an integer twice?

      • nascardriver

        June 18, 2020 at 4:52 am · Reply

        It's fine as it is

• Nahin

  June 1, 2020 at 11:28 am · Reply

  Do those 'multiple declarations' in the sentence below refer to the forward declarations of a non-static function in as many files as we want?

  > Linkage defines whether multiple declarations refer to the same object or not.

  • nascardriver

    June 2, 2020 at 6:44 am · Reply

    Yes, it's talking about forward declarations. You can place the forwards declarations in as many files as you want.

• AE35_Unit

  May 24, 2020 at 4:22 pm · Reply

  Thanks Nascar, I went back and looked at all your recommendations, they really helped. I can't thank you enough. My code looks better and proper now.  AS far as where I am with studying, I've just been going straight through this lesson plan from the beginning.  I've seen tutorial videos on the youtube and would based on the one C++ class I had at university I would say I'm about one and 1/3 semesters.  I just enough about classes to creates small and easy ones so I'm looking forward to your sections on the subject. Also I used pointers and references pointers in the above, I try to use them if I'm able so as to get a more solid understanding of them as well. I see that the pointers section are in the near future.  Right now I'm at 6.9 Why global variables are evil, and after I finish all of 6 I'll probably go back for a bit of review.  Again, thanks for all your help. Cheers.

• AE35_Unit

  May 22, 2020 at 10:23 pm · Reply

  Again trying to utilize concepts learned from previous chapters.  This could be written a lot faster and easier to read but I find that by using previous lessons I get a better grasp on the course's teaching's.

  ae35unit.cpp

  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

  #include <iostream>   namespace ae35unit {   int_fast16_t setSmaller()   {     std::cout << "Enter an integer: ";       int_fast16_t ns_Smaller{}; // ns_Smaller alive     std::cin >> ns_Smaller;       return ns_Smaller;   } // ns_Smaller killed     int_fast16_t setLarger()   {     std::cout << "Enter a larger integer: ";       int_fast16_t ns_Larger{}; // ns_Larger alive     std::cin >> ns_Larger;       return ns_Larger;   } // ns_Larger killed     void setOrder(int_fast16_t *pSmaller, int_fast16_t *pLarger)   {     if (*pSmaller > *pLarger)     {       int_fast16_t temp{}; // temp alive         temp = *pSmaller;       *pSmaller = *pLarger;       *pLarger = temp;     } // temp killed   } } // namespace ae35unit

  main.cpp

  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 "ae35unit.cpp" #include <iostream>   void print_fast16_tNumbers(int_fast16_t smaller, int_fast16_t larger) {   std::cout << "The smaller value is " << smaller << std::endl;   std::cout << "The larger value is " << larger << std::endl; }   void setSmaller(); void setLarger(); void setOrder(int_fast16_t *pSmaller, int_fast16_t *pLarger);   int main()  // main alive {   namespace ae = ae35unit; // namespace ae alive     int_fast16_t smaller{ae::setSmaller()}; // smaller alive   int_fast16_t larger{ae::setLarger()};   // larger alive     ae::setOrder(&smaller, &larger);     ::print_fast16_tNumbers(smaller, larger);     return 0; } // smaller, larger, ae and main killed

  • nascardriver

    May 23, 2020 at 2:17 am · Reply

    If you let me know how much of C++ already know by stating a chapter number (eg. "I know C++ up to, and including, chapter P") I can give you better suggestions.

    Still going with your lander huh? That's nice, keeps the fun up :)

    - Missing #include <cstdint>
    - `int_fast16_t` should be `std::int_fast16_t`
    - By using pointers, you're allowing the caller to pass in a `nullptr`. This can be avoided by using `gsl::not_null` from the guidelines support library or by using references.
    - If you can, initialize variables (`temp`).
    - main.cpp:16: `ae` is not an object, it has no lifetime, only a scope. We talk about the scope later in this chapter.
    - main.cpp:23: There's no need for a global namespace selector here.

    If you weren't programming a lander, here are some extra notes that I don't want to let go unnoticed:
    - Don't restrict integers unless you have a reason to (Your reason is speed). Plain `int` is fine most of the time.
    - Don't use `std::endl` unless you have a reason to (Your reason is that logs are critical).