This is a post concerning what we call "scope" in C++. This should also be applicable to C and Java etc in some respects, but will be biased towards C++ and any code shown will be C++. (Because it is the real man's programming language, lol)

So, basically, we can define your scope as your present working surface. Programs can normally be thought of having 2 or more scopes at any given time (supposing you are inside a function at all times).

Thusly, we have the Global Scope and the Local Scope, plus Namespaces, which will be dealt with at a later time. The Global Scope includes anything declared outside of your functions, classes, etc. Your local scope would include anything inside the function you are currently in.

so if we had a program that looked like:

#include<iostream>
using namespace std;

int x, y;

int main(void)
{
	int a,b;
	return 0;
}

Looking at this, we really only need to think in terms of 2 scopes. There is the local scope, and there is the global scope. The global scope contains the variables x and y, and the function main, plus anything defined in iostream, within the namespace std. A namespace is basically a method of encapsulating data, which is a big deal in C++, but will not be addressed here, as to not loose focus. The local scope of the function main includes the variables a and b. Because x and y are declared in the global scope, they can be used in main as if they were declared in main, and any other function, and will retain their values as they are modified by functions. So, say I set x equal to zero in one function, then 4 in another. when I exit the second function, x is still 4. Simple? Good.

Say we had another function in this, call it functionA, like so:

[code]
#include<iostream>
using namespace std;

// prototype
int functionA(void);

int x, y;

int main(void)
{
	int a,b;
	return 0;
}

int functionA(void)
{
	x = 0;
	return 0;
}

As it is declared now, the function functionA is available globally. If you were to put the prototype statement into main, or any other function, the function then only exists in the scope of that function.
Also, If I were to call functionA in main or any other function, the variables in the original function will no longer be available, thus being why we use function parameters. So, if I wanted to access the value of a in functionA, I would need to tell it to take an integer:
int functionA(int var)
If i wanted to change the value permanently, I would hand it to the function as a reference variable:
int functionA(int& var)

both of these will allow me to just pass a itself from main like so:
functionA(a);

but the second will allow you to manipulate a, while the first will only allow you to get a copy of a.

A scope can also be established inside a function.
for example, the if statement.
if I have a function with an if statement inside of it like so:

void functionB(void)
{
	if(x != 0)
	{
		int a = x + 4;
		cout << a;
	}
}

There are 2 scopes here, the local scope and the if statement scope. The if statement scope can access variables from the local and global scope, but after the terminating } of the if statement, the variable a disapears.

It's really late right now, And I dont feel like talking about namespaces, but look em up cuz they rock, and if anyone actually finds this helpful, and wants me to write up something on namespaces, just leave a comment. Also, any questions or concerns can be left as comments.

peace
~Bodom