Streams

Chapter 12: Streams II

Starting a program by typing the name of the program at a prompt in a terminal or shell window is called "invoking the program from the command line."
When you use this method, you can also type in additional information, called command line arguments, that the program can use.
```
prog -v input.dat
```
Only text mode programs (console applications) receive command line arguments - in this case the strings "prog", "-v" and "input.dat".
The graphics library that comes with our textbook does not collect them.
To receive command line arguments, you need to define the main
function in a different way.
```
int main(int argc, char* argv[])
{
   . . .
}
```
- argc is the count of arguments.
- argv contains the values of the arguments.
Note that argc is an array of pointers to C character arrays.

In the invocation above, argc is 3 and argv contains (pointers to) the strings

argv[0]:
"prog"

argv[1]:
"-v"

argv[2]:
"input.dat"

Note that argv[0] always points to the name of the program and that argc is always at least 1.
You can convert C strings to C++ string using casting: static_cast<string>(argv[i]) or string(argv[i]).

The sample program (caesar.cpp) is used to encrypt a file - that is, scrambles it so that it is unreadable except to those who know the decryption method and the secret keyword.

This program uses a method familiar to Julius Caesar.

The person performing any encryption chooses an encryption key (a number between 1 and 25).

The key indicates the shift to be used in encrypting each letter. (For example, if the key is 3, we replace A with D, B with E, etc.).

Plain Text
M e e t
m e
a t . . .

Encrypted Text
P h h w
p h
d w . . .

The program takes the following command line arguments:
- An optional -d flag to indicate decryption instead of encryption.
- An optional encryption key, specified with a -k flag. (If no key is specified, then 3 is used).
- The input file name.
- The output file name.

Examples:

caesar input.txt encrypt.txt
caesar -d -k11 encrypt.txt output.txt

In the above, we read from a file an item at a time and wrote to a file an item at a time. That access pattern is called sequential access.
Random access allows us to access specific location in a file and only change those locations.
The term "random" means you can read and modify any character stored at any location in the file.
Only disk files support random access, the cin and cout streams, which is usually attached to the keyboard and the terminal, do not.
Each disk file has two special positions:
- The get position indicates the next read command starts reading input at the location.
- The put position indicates where to write the next output.
Normally the get position starts at the beginning of the file and is moved towards the end.
Normally the put position always points to the end.
By moving the get and put positions, you can achieve random access.

The follow calls move the get and put positions to character n counted from the beginning of the file fs.
```
fs.seekg(n, ios::beg);
fs.seekp(n, ios::beg);
```
The second argument can be ios:end or ios::cur to move the position n characters away from the end of the file or the current position, respectively.
To determine the current position of the get and put positions (in bytes, counted from the beginning of the file), use
```
n = fs.tellg();
n = fs.tellp();
```
Because the files can be very large, the positions are long integers.
To find out the number of characters in a file, move the get position to the end and then find out the distance from the beginning of the file.
```
fs.seekg(0, ios::end);
long file_length = fs.tellg();
```

When manipulating data with random access, we have to pay special attention to the formatting of the data.
Example: Suppose we store the data as text:

Then raise Harry's salary by 5.5 percent to $36,397.50.

The update overwrites some characters in the next field.
In order to be able to update a file, we must give each filed a fixed size that is sufficiently large.
As a result, every record (logical unit) in the file has the same size, making it easy to jump over records.
Example: We will restructure our records above to
Name: 30 characters
Salary: 10 characters