Completely lost on Scope and Functions? Any other way to explain them?

I'll start with functions. These are essentially blocks of code that can be run by typing a single line, instead of typing the block over and over again. For example, the C code you'd write for a program is in a function named main(). Below is an example of a function that would take in 2 ints, add them together, and send back the sum:

int addTwoNumbers(int first, int second){
    int sum = first + second;
    return sum;
}

Note that all functions are declared outside of any other functions, such as main. The way that you would run that code in the function is something like this:

int main(){
    int one = 1;
    int two = 2;
    int sum = addTwoNumbers(one, two);
    printf("The sum of %d and %d is %d", one, two, sum);
    //The main function always returns 0, just to tell the operating system that everything ran properly
    return 0;
}

In this case, the numbers 1 and 2 were added together by the addTwoNumbers() function I previously defined, and the sum (returned by my function) was assigned to the variable sum.

You an think of functions as a way to have the computer copy and paste your code in a certain spot.

Now onto the concepts of scope. Did you notice how I defined two variables named sum in my previous example? That's perfectly legal. This is because they're each only in their own function, and they're therefore only visible to the function they're defined in. In other words, the sum in the function main() is totally different from the sum in the function addTwoNumbers(). They can equal different things, and even be different data types. They're totally independent of each other.

Now let's say that I defined the sum variable outside of any function, like this:

int sum = 0;

int addTwoNumbers(int first, int second){
    //Notice how I don't write "int" before "sum"
    sum = first + second;
    return sum;
}

int main(){
    int one = 1;
    int two = 2;
    //Same as above, notice the lack of "int"
    sum = addTwoNumbers(one, two);
    printf("The sum of %d and %d is %d", one, two, sum);
    return 0;
}

Although this example should end in the same result as the first, what's happening is different. Instead of each function having its own unique variable named sum, each function is operating on the same variable. I could write another function that uses the sum variable, and it'd be operating on the same variable as the other 2 functions. That because in this case, sum is declared a the Global scope. That means any part of your code anywhere in that file can see it and change it. This is as opposed to the Local scope, like in the first function, where each sum variable was only visible to its own respective function.

Loops have their own scope, too. Any variable defined in a loop is only available to that loop. Take this code for example:

//This statement is only necessary if you want to copy and paste this verbatim. You'll need this if you do the same with any of the rest of my examples
#include <stdio.h>
int main(){
    int number = 0;
    for(int i = 0; i < 10; i++){
        //If you're not familiar with the "++" operator, all it does is add one to the variable it's next to
        number++;
        int incremented = number;
        printf("number + 1 = %d. This is iteration %d", incremented, i);
    }
    return 0;
}

Go ahead and copy and paste this code into a blank C file and run it.

In that example, incremented is only available inside that loop. If I tried to refer to it outside the loop (even if it was after the loop), the compiler wouldn't know what I was talking about, and the code wouldn't compile. However, notice that I was allowed to refer to number just fine inside the loop, even though it was defined before the loop. This is just fine, because it's still defined in the same function as the loop. It would also be available in the loop if it was a Global variable. Also, on a side note, notice how I was allowed to use i in the loop (not outside, however, because it's technically defined in the loop). Although it may look like it has its own scope (because it's defined in the parentheses), it's really at the same scope as incremented.

It's not just for(){} loops that have their own scope. This is true in while(){} and do{}while(): loops, too.

Essentially, scope gets more specific with each nested block of code. That means that variables defined in a certain block of code are only available to that block and other blocks inside of said block, like loops within functions, like above. You can access any variable defined in your scope or higher, but not lower than your scope.

On a final note, this means that you must also be careful about your variable names as you get more specific in scope. Because every variable at a higher scope is available to any lower scope, you can't define a variable in a lower scope that has already been defined in a higher one. This, for example, is illegal:

int number = 0;
int main(){
    //The following definition is illegal, because of the "int" keyword
    int number = 1;
    for(int i = 0; i < 10; i++){
        //This next declaration is illegal for the same reason as the previous one
        float number = 3.5;
        printf("This program will have crashed by now");
    }
    return 0;
}

I hope that all made sense. Just reply to this if you have any questions

Hi Zach,

A short answer would be:

A function is a programming concept/tool that allows us to manipulate words and numbers (data).

Next, think of the scope on a rifle. It allows you to see a limited, but precise view of area.

That's what Scope is.

When we apply the idea of Scope to variables, we get words and numbers(data) that can only be seen at certain times and in certain ways.

Cheers ~