Defining Command Line Arguments w/ functions - c

Question

The following code:
#include<stdio.h>
void main(int argc, char * argv[]) {
int i, n, sum = 0;
if (argc == 1) {
printf("You have forgot to type numbers.");
exit(1);
}
printf("The sum is: ");
///for (i = 1; i < argc; i++)
///sum = sum + atoi(argv[i]);
for(i = 0; i < argc; i++)
{
n = atoi(argv[i]);
sum += n;
}
printf("%d", sum);
}
gives me the sum in the command line, so for example if at the prompt I type, "program.exe 23 23 32", the output will be "The sum is: 68".
I would like to separate the sum logic so that it's its very own function, and then at the prompt I would like to be able to type, "program.exe -sum 23 23 32" to get the same result.

Answer 1

I found this and this. The latter contained some useful code, doing almost exactly what you want. Their example requires knowing how many arguments are being taken (the for loop in the sum function contains i < 5), but there could be a way of working around that.
man 3 stdarg should be helpful aswell.

Answer 2

It seems to me that you don't really need the - in front of sum; the first argument should be a simple string:
program.exe sum 1 3 5 9
Whether you keep the dash or not, you can simply arrange to pass a pointer to the remainder of the argument list to a function which expects that:
int sum(int numc, char **numv)
which returns the sum of the numc numbers represented as strings in the number vector numv. You can call that easily enough:
int rv = sum(argc - 2, argv + 2);
after you've established that sum is the function to call. And you can have a collection of such functions.
If you've encountered function pointers, you could create yourself an array of names (that the user will type on the command line) and function pointers (which point to the corresponding function). Then you simply have to look up the name the user typed in the array and call the appropriate function. That's probably still for the future for you, though.

Answer 3

In a lot of C code, we take shortcuts to make parsing easier. For example, let's say we know that we only have 2 choices of operator: sum or product. We then know that the first argument must be either -sum or -product. We can simplify the parsing by just checking for - followed by either s or p.
As for abstracting the actual operator, in this case it's probably more efficient to just check which operator was chosen on the command line, and then either apply += or *= based on that.
Here is some working code:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char * argv[]) {
int n;
int result;
int i = 1;
char operator;
// parse -sum or -product
if (argv[i] && argv[i][0] == '-') {
// we take a shortcut and just look at the first letter
char firstLetter = argv[i][1];
if (firstLetter == 's') {
// using sum
operator = '+';
result = 0; // additive identity
}
else if (firstLetter == 'p') {
// using product
operator = '*';
result = 1; // multiplicative identity;
}
else {
printf("Unknown option: %s\n", argv[i]);
exit(1);
}
// move on to the next argument
i++;
}
else {
printf("Please specify an operation (-sum or -product)\n");
exit(1);
}
if (!argv[i]) {
printf("You have forgot to type numbers.\n");
exit(1);
}
for(; argv[i]; i++) {
n = atoi(argv[i]);
if (operator == '+') {
result += n;
}
else { // if (operator == '*')
result *= n;
}
}
printf("The result is: %d\n", result);
return 0;
}
Notice that the initial value of result is different depending on which operation was chosen.
Rather than using argc, the code above takes advantage of the fact that the argv array is null-terminated. In other words, if you had 3 arguments (or argc=4), then argv[3] will be NULL (which is equivalent to 0 or false).
Note that if you turn on optimizations, then any decent C compiler will move the test outside the loop, so it only actually checks which operator was chosen once. (This is easily verifiable by looking at the produced assembly code.)