{"id":11879,"date":"2025-09-09T03:00:00","date_gmt":"2025-09-09T07:00:00","guid":{"rendered":"https:\/\/www.both.org\/?p=11879"},"modified":"2025-09-08T11:11:11","modified_gmt":"2025-09-08T15:11:11","slug":"reading-the-command-line-with-getopt","status":"publish","type":"post","link":"https:\/\/www.both.org\/?p=11879","title":{"rendered":"Reading the command line with getopt"},"content":{"rendered":"
\r\n
\r\n \r\n <\/i>\r\n <\/a>\r\n <\/span>\r\n<\/div><\/div>\n

Writing a C program to process files is easy when you already know what files you’ll operate on and what actions to take. If you “hard code” the filename into your program, or if your program is coded to do things only one way, then your program will know exactly what to do. That makes it very easy to write.<\/p>\n\n\n\n

But a program that uses “hard coded” values like that will be very limited because it can only do that one thing<\/em>. Instead, you can make your program\u00a0much more flexible if it can respond to the user every time the program runs<\/em>. Let your user tell your program what files to use or how to do things differently. And for that, you need to read the command line.<\/p>\n\n\n\n

Reading the command line<\/h2>\n\n\n\n

When you write a program in C, you might start with the declaration:<\/p>\n\n\n\n

int main()<\/code><\/pre>\n\n\n\n
That’s the simplest way to start a C program. But if you add these standard parameters in the parentheses, your program can read the options given to it on the command line:<\/p>\n\n\n\n
int main(int argc, char **argv)<\/code><\/pre>\n\n\n\n
The argc<\/code> variable is the argument count or the number of arguments on the command line. This will always be a number that’s at least one.<\/p>\n\n\n\n
The argv<\/code> variable is a double pointer, an array of strings, that contains the arguments from the command line. The first entry in the array, argv[0]<\/code>, is always the name of the program. The other elements of the **argv<\/code> array contain the rest of the command-line arguments.<\/p>\n\n\n\n
I’ll write a simple program to echo back the options given to it on the command line. This is similar to the Linux echo<\/code> command, except it also prints the name of the program. It also prints each command-line option on its own line using the puts<\/code> function:<\/p>\n\n\n\n
#include <stdio.h>\n\nint\nmain(int argc, char **argv)\n{\n  int i;\n\n  printf(\"argc=%d\\n\", argc); \/* debugging *\/\n\n  for (i = 0; i < argc; i++) {\n    puts(argv[i]);\n  }\n\n  return 0;\n}<\/code><\/pre>\n\n\n\n
Compile this program and run it with a few command-line arguments, such as a few extra words, and you’ll see your command line printed back to you and each item on its own line<\/em>:<\/p>\n\n\n\n
$ .\/echo this program can read the command line\nargc=8\n.\/echo\nthis\nprogram\ncan\nread\nthe\ncommand\nline<\/code><\/pre>\n\n\n\n
This command line sets the program’s argc<\/code> to 8<\/code>, and the **argv<\/code> array contains eight entries: the name of the program, plus the seven words the user entered. And as always in C programs, the array starts at zero, so the elements are numbered 0, 1, 2, 3, 4, 5, 6, 7. That’s why you can process the command line with the for<\/code> loop using the comparison i < argc<\/code>.<\/p>\n\n\n\n
You can use this to write your own versions of the Linux cat<\/code> or cp<\/code> commands. The cat<\/code> command’s basic functionality displays the contents of one or more files. Here’s a simple version of cat<\/code> that reads the filenames from the command line:<\/p>\n\n\n\n
#include <stdio.h>\n\nvoid\ncopyfile(FILE *in, FILE *out)\n{\n  int ch;\n\n  while ((ch = fgetc(in)) != EOF) {\n    fputc(ch, out);\n  }\n}\n\nint\nmain(int argc, char **argv)\n{\n  int i;\n  FILE *fileptr;\n\n  for (i = 1; i < argc; i++) {\n    fileptr = fopen(argv[i], \"r\");\n\n    if (fileptr != NULL) {\n      copyfile(fileptr, stdout);\n      fclose(fileptr);\n    }\n  }\n\n  return 0;\n}<\/code><\/pre>\n\n\n\n
This simple version of cat<\/code> reads a list of filenames from the command line and displays the contents of each file to the standard output, one character at a time. For example, if I have one file called hello.txt<\/code> that contains a few lines of text, I can display its contents with my own cat<\/code> command:<\/p>\n\n\n\n
$ .\/cat hello.txt \nHi there!\nThis is a sample text file.<\/code><\/pre>\n\n\n\n
Using this sample program as a starting point, you can write your own versions of other Linux commands, such as the cp<\/code> program, by reading only two filenames: one file to read from and another file to write the copy.<\/p>\n\n\n\n
Reading command-line options<\/h2>\n\n\n\n
Reading filenames and other text from the command line is great, but what if you want your program to change its behavior based on the options<\/em> the user gives it? For example, the Linux cat<\/code> command supports several command-line options, including:<\/p>\n\n\n\n