Switch-Case Operator -- C - c

Question

Is there a way to store user inputs in switch case from one operation and use it across switch operations at run-time.
Example: If its a software for a Bank and I want to take information from the user and validate if his a/c number is correct and also check if he has enough bank balance to withdraw money.
I need to know how to store the value of one operation,so that I could use it for further ops.
switch(ops)
{
char ac_no;
long amt,amt2,init_dep;
char name,ac_allocated;
case OpenAC:
{
printf("1.Name:\n");
scanf("%s",&name);
printf("2.A/Cno_allocated:\n");
scanf("%s",&ac_allocated);
printf("3.Initial deposit:\n");
scanf("%d",&init_dep);
break;
}
case Deposit:
{
printf("Enter the a/c number: ");
scanf("%s",&ac_no);
printf("Amount:Rs. ");
scanf("%ld",&amt);
break;
}
case Withdraw:
{
printf("Enter the a/c number: ");
scanf("%s",&ac_no);
printf("Amount:Rs. ");
scanf("%ld",&amt2);
{printf("Cannot withdraw.Rs.500 minimum balance mandatory.\n");}
break;
}
return ops;
}
I also tried declaring variables in the switch(ops) to store the value in them(like in the following case to validate the a/c number in the next step but it doesn't help.)
Edited code:
`
char ac_no;
long amt,amt2,init_dep,dep1;
char name,ac_allocated,ac1;
case OpenAC:
{
printf("1.Name:\n");
scanf("%s",&name);
printf("2.A/Cno_allocated:\n");
scanf("%s",&ac_allocated);
ac_allocated = ac1;
printf("3.Initial deposit:\n");
scanf("%d",&init_dep);
init_dep = dep1;
//break;
}
case Deposit:
{
printf("Enter the a/c number: ");
scanf("%s",&ac_no);
if(ac_no == ac1)
{
printf("Amount:Rs. ");
scanf("%ld",&amt);
}
break;
`

Answer 1

Why not declare your variables outside the switch. You could even put braces around the switch to prevent the variables from leaking to the surrounding function, like this:
// code from the surrounding function
{
char ac_no;
long amt,amt2,init_dep;
char name,ac_allocated;
switch(ops)
{
case OpenAC:
...
}
} // end of block

Answer 2

I'm not sure I understand your problem, but if you declare something inside the curly brackets of the switch statement, it will be out of scope when you hit the ending curly bracket and not usable the next time the switch statement is encountered.

Answer 3

First issue: you're using the wrong type for ac_no, name, ac_allocated, and ac1. You're obviously wanting to store strings at these locations, so instead of a plain char, you need to declare arrays of char:
char ac_no[AC_NO_SIZE];
char name[NAME_SIZE];
char ac_allocated[AC_ALLOCATED_SIZE];
char ac1[AC1_SIZE];
where each *_SIZE is large enough to hold your input data plus 1 extra character for the 0 terminator. IOW, if your account numbers are at most 10 characters long, AC_NO_SIZE needs to be 11.
Second issue: do not declare variables at the head of a switch statement; any initializations will be skipped.
Third issue: auto variables declared inside a specific scope will not be available outside of that scope; they will cease to exist when that scope exits. None of the variables you declare will be available outside of the switch statement.
Fourth issue: if this switch operation is inside of a function, and you want to preserve these values between function calls, you can do one of three things:
Declare these items at file scope, outside of any function (not recommended):
char ac_no[AC_NO_SIZE];
char name[NAME_SIZE];
char ac_allocated[AC_ALLOCATED_SIZE];
char ac1[AC1_SIZE];
long amt, amt2, init_dep;
void foo()
{
int ops;
...
ops = bar(ops);
...
}
int bar(int ops)
{
switch(ops)
{
case OpenAC:
printf("Name: ");
fflush(stdout);
scanf("%s", name); // note no &; true for all char [] types
printf("A/C no allocated: ");
fflush(stdout);
scanf("%s", ac_allocated);
printf("Initial deposit: ");
fflush(stdout);
scanf("%ld", &init_dep);
...
}
return ops;
...
Declare these items as `static` in the function (slightly less recommended); they will not be visible outside of the function, but their value will be retained between function calls:
int bar(int ops)
{
static char ac_no[AC_NO_SIZE];
static char name[NAME_SIZE];
static char ac_allocated[AC_ALLOCATED_SIZE];
static char ac1[AC1_SIZE];
static long amt, amt2, init_dep;
switch(ops)
{
case OpenAC:
printf("Name: ");
fflush(stdout);
scanf("%s", name);
printf("A/C no allocated: ");
fflush(stdout);
scanf("%s", ac_allocated);
printf("Initial deposit: ");
fflush(stdout);
scanf("%ld", &init_dep);
...
}
return ops;
}
Declare these items in the calling function and pass them as parameters to this function (recommended):
int foo(int ops,
char *ac_no,
char *name,
char *ac_allocated,
char *ac1,
long *amt, // Since these values are being modified in the function,
long *amt2, // we must pass pointers to them, otherwise the changes
long *init_dep) // will not be reflected in the calling function
{
switch(ops)
{
case OpenAC:
printf("Name: ");
fflush(stdout);
scanf("%s", name); // no & before name; same is true for rest of parameters
printf("A/C no allocated: ");
fflush(stdout);
scanf("%s", ac_allocated);
printf("Initial deposit: ");
fflush(stdout);
scanf("%ld", init_dep); // no & before init_dep since it's already a pointer
...
All of this assumes I'm understanding your problem correctly.

Answer 4

Maybe you should use structure to hold account data and functions to make it readable and maintainable.
struct account_s { /* Fields borrowed to #John Bode */
char ac_no[AC_NO_SIZE];
char name[NAME_SIZE];
char ac_allocated[AC_ALLOCATED_SIZE];
char ac1[AC1_SIZE];
long amt, amt2, init_dep;
};
int openAC(struct account_s *account);
to be continued... :)