Trying Not To Use Global Variables With Function

I want to have this function plus a variable by one. and it does. But i want to do it without using global variables, as i have read it is poor design. Does that mean you don't need to declare variables at all? I have seen this work that way (i think), but no matter what I seem to need to declare the int x in order to make this work.

How can i make this work without global variables, and do i need to declare x at all?

Code:

---

#include<stdio.h>


/*local function prototype*/
int plus();

/*main function*/
int main(int argc, char * argv[])

{
 
    x = 1;
    printf("x = %d \n",x);
   
    /*impliment the plus function*/
    x = plus(x);

    printf("\nx = %d",x);
   

    getch();
    return 0;
}

/*local function*/
int
plus(int input)
{
    return input + 1;
}

---

Quote:

---

Originally Posted by Krash005

I want to have this function plus a variable by one. and it does. But i want to do it without using global variables, as i have read it is poor design. Does that mean you don't need to declare variables at all? I have seen this work that way (i think), but no matter what I seem to need to declare the int x in order to make this work.

How can i make this work without global variables, and do i need to declare x at all?

Code:

---

#include<stdio.h>


/*local function prototype*/
int plus();

/*main function*/
int main(int argc, char * argv[])

{
 
    x = 1;
    printf("x = %d \n",x);
   
    /*impliment the plus function*/
    x = plus(x);

    printf("\nx = %d",x);
   

    getch();
    return 0;
}

/*local function*/
int
plus(int input)
{
    return input + 1;
}

---

---

Declare x at local scope in main()

i.e.

Code:

---

int main(int argc, char * argv[])
{
    int x = 1;

  ...
}

---

No need for 'x' to be at global scope.

But is that still bad design? I guess I am not really understanding why globals are bad, for locals are okay.

Globals are bad coz if they unintentionally get changed in some other function then it'll be messy. I dont know better reason than that, but surely if someone can clarify more on it.

Global variables are bad

Global variables requires a carefull mind of the programmer, but its not necessarily bad design. The same applies to goto, which is highly useful in error correction in the lack of better methods, like exceptions.

Global variables can be modified at any time, resulting in potentially unpredictable result in case of unindended modifications, and it can be harder to discover the source of the error. This is the reason its classified as bad design, however, the fact remains that there are not major principal difference between a file scope global variable in C or a class scope variable in C++ or Java.

What you should do is keep the scope of the global variable to the actual code space where its needed, in C this usually refers the the C file where its defined. To do that you decalare it static:

Code:

---

static int g_Variable;

---

Now the variable is not visible outside the C file. Personally I keep all code space variables in a static struct, marking local to that perticular scope, like this:

Code:

---

static struct{
    int a;
    int b;
}locals;

---

Then you can access the locals in the code scope like this locals.a or locals.b, which is in my opinion no different from class scope variables in other languages and you never hear anything about bad design.

I agree with glennik. There are circumstances where not using a global can be much more awkward than using one. There are also libraries that force you to do so, because they involve callbacks that do not take ANY parameters.

However, as zacs7 points out, your case is not one of these, you do not need a global, so don't use one.

Quote:

---

Originally Posted by glennik

Global variables requires a carefull mind of the programmer, but its not necessarily bad design.

---

While I can agree with this statement...

Quote:

---

Originally Posted by glennik

This is the reason its classified as bad design, however, the fact remains that there are not major principal difference between a file scope global variable in C or a class scope variable in C++ or Java.
(...)
Then you can access the locals in the code scope like this locals.a or locals.b, which is in my opinion no different from class scope variables in other languages and you never hear anything about bad design.

---

Class scope variables in such languages, especially if they have non-private access, are symptomatic of bad design, for the same reasons as global variables. One should not use such language features to broadly justify global variables. I would rather justify the use of global variables by considering that for some programs, the presence of globally shared data (rather than just global constants) may be inherent in the problem that the program is supposed to solve, and reuse for non-global data is regarded as very improbable.

Quote:

---

Originally Posted by laserlight

While I can agree with this statement...


Class scope variables in such languages, especially if they have non-private access, are symptomatic of bad design, for the same reasons as global variables. One should not use such language features to broadly justify global variables. I would rather justify the use of global variables by considering that for some programs, the presence of globally shared data (rather than just global constants) may be inherent in the problem that the program is supposed to solve, and reuse for non-global data is regarded as very improbable.

---

Compared to what you are referring to, using a class scope variable with public access, would i C be using an extern decalaration, which is pretty much the opposite of what I stated.

However, I should have elaboreted upon the detail that I was aiming at private class scope variables, as compared to global variables with C file scope, which in my opinion, does not represent any major principal difference.

And, I never said that laguage features, like declaring a global variable static, justifies a broad use of global variables. But, in real life applications, global variables at some level are necessary and then you should use the tools in the toolbox to limit the possible undesired consequences, and using a static struct is such a tool, and not a general justification of global variables.