Is there any way in c to change the value of a global variable through a function without passing it to the function?

C Programming - Very basic and powerful High level language

In C there are two types of access scope for variables :

1. Global scope - can be accessed throughout the program
2. Local scope - can be accessed only inside a block where it is created

Now the need is to change the value of global variable without passing it to a function. Lets see how we are going to do this.

There are two ways to achieve this,

• Assigning value directly to global variable

1. //including C standard input/output library 
2. #include  
3.  
4. //Global variable 
5. int a = 5; 
6.  
7. //declaring required function 
8. void change(); 
9.  
10. //main program 
11. void main(){ 
12. printf("\n Before function call => a = %d\n", a); 
13. change(); 
14. printf("\n After function call => a = %d\n", a); 
15. } 
16.  
17. //defining the above declared function 
18. void change(){ 
19. //just assigning 10 to a 
20. a = 10;  
21. } 

Inside function change [Line 14 - 16], when [math]a[/math] is called it directly points to the global variable and assigns value to it.

Now let us consider next method.

• Using pointer concept

1. //including C standard input/output library 
2. #include  
3.  
4. //Global variable 
5. int a = 5; 
6.  
7. //declaring required function 
8. void changeUsingPtr(); 
9.  
10. //main program 
11. void main(){ 
12. printf("\n Before function call => a = %d\n", a); 
13. changeUsingPtr(); 
14. printf("\n After function call => a = %d\n", a); 
15. } 
16.  
17. //defining the above declared function 
18. void changeUsingPtr(){ 
19.  
20. //pointer declared 
21. int *b; 
22.  
23. //address of variable a is assigned to b 
24. b = &a; 
25.  
26. //value present in address is incremented 
27. ++*b; 
28. } 

Here a pointer is declared which holds the address of global variable and the value in the address is incremented after de-referencing, which forces to use pre-increment. Post increment doesn’t help on this.

The output remains the same for both case.

Output :

Before function call => a = 5

After function call => a = 10

In both cases, we need to ensure there is no conflicts between local and global variable. No local variable and global variable should be declared with same name.

So what if we stuck in the above scenario, having a conflict between two scope variables. Adding a small code block will help us cross the line. Hang on✋, Will show you how to make it.

1. //including C standard input/output library 
2. #include  
3.  
4. //Global variable 
5. int a = 5; 
6.  
7. //function for returning the global variable address 
8. int* globalVarAddress(){ 
9. return &a; 
10. } 
11.  
12. //declaring required function 
13. void changeUsingPtr(); 
14.  
15. //main program 
16. void main(){ 
17. printf("\n Before function call => a = %d\n", a); 
18. changeUsingPtr(); 
19. printf("\n After function call => a = %d\n", a); 
20. } 
21.  
22. //defining the above declared function 
23. void changeUsingPtr(){ 
24.  
25. //local variable using same name as global 
26. int a = 10; 
27.  
28. //pointer declared 
29. int *b; 
30.  
31. //fn call returns address of global a 
32. b = globalVarAddress(); 
33.  
34. //value present in address is incremented 
35. ++*b; 
36. } 

Output will be the same as above.

In Line 21, if we use [math]&a[/math] same as previous case then the address of local variable will be stored in [math]b[/math] since local variable always wins in local global conflicts. Using so will increment local variable [math]a[/math] to [math]11[/math] and global a remains unchanged.

Hope we are done with it.

[math]while(noSuccess){ tryAgain(); } - #Nk :) [/math][math] [/math]