There’s three ways to create programs that write data to files and read data from files. When a file is used by a program, three steps must be taken.

1. Open the file — Opening a file creates a connection between the file and the program. Opening an output file usually creates the file on the disk and allows the program to write data to it. Opening an input file allows the program to read data from the file.
2. Process the file — Data is either written to the file (if it is an output file) or read from the file (if it is an input file).
3. Close the file — After the program is finished using the file, the file must be closed. Closing a file disconnects the file from the program.

File Access Methods

There are two general ways to access data stored in a file: sequential access and direct access. When you work with a sequential access file, you access data from the beginning of the file to the end of the file. If you want to read a piece of data that is stored at the very end of the file, you have to read all of the data that comes before it — you cannot jump directly to the desired data. This is similar to the way cassette tape players work. If you want to listen to the last song on a cassette tape, you have to either fast-forward over all of the songs that come before it or listen to them. There is no way to jump directly to a specific song.

When you work with a random access file (also known as a direct access file), you can jump directly to any piece of data in the file without reading the data that comes before it. This is similar to the way a CD player or an MP3 player works. You can jump directly to any song that you want to listen to.

In order for a program to work with a file on the computer’s disk, the program must create a file stream object in memory. A file stream object is an object that is associated with a specific file and provides a way for the program to work with that file. It is called a “stream” object because a file can be thought of as a stream of data.

File stream objects work very much like the cin and cout objects. A stream of data may be sent to cout, which causes values to be displayed on the screen. A stream of data may be read from the keyboard by cin, and stored in variables. Likewise, streams of data may be sent to a file stream object, which writes the data to a file. When data is read from a file, the data flows from the file stream object that is associated with the file, into variables.

Setting Up a Program for File Input/Output

Just as cin and cout require the iostream file to be included in the program, C++ file access requires another header file. The file fstream contains all the declarations necessary for file operations. It is included with the following statement:

#include <fstream>

The fstream header file defines the data types ofstream, ifstream, and fstream. Before a C++ program can work with a file, it must define an object of one of these data types. The object will be “linked” with an actual file on the computer’s disk, and the operations that may be performed on the file depend on which of these three data types you pick for the file stream object. Table below lists and describes the file stream data types.

Creating a File Object and Opening a File

Before data can be written to or read from a file, the following things must happen:

• A file stream object must be created
• The file must be opened and linked to the file stream object.

The following code shows an example of opening a file for input (reading).

ifstream inputFile;
inputFile.open(“Customers.txt”);

The first statement defines an ifstream object named inputFile. The second statement calls the object’s open member function, passing the string “Customers.txt” as an argument. In this statement, the open member function opens the Customers.txt file and links it with the inputFile object. After this code executes, you will be able to use the inputFile object to read data from the Customers.txt file.

The following code shows an example of opening a file for output (writing).

ofstream outputFile;
outputFile.open(“Employees.txt”);

The first statement defines an ofstream object named outputFile. The second statement calls the object’s open member function, passing the string “Employees.txt” as an argument. In this statement, the open member function creates the Employees.txt file and links it with the outputFile object. After this code executes, you will be able to use the outputFile object to write data to the Employees.txt file. It’s important to remember that when you call an ofstream object’s open member function, the specified file will be created. If the specified file already exists, it will be erased, and a new file with the same name will be created.

It is possible to define a file stream object and open a file in one statement. Here is an example:

ifstream inputFile(“Customers.txt”);

This statement defines an ifstream object named inputFile and opens the Customer.txt file. Here is an example that defines an ofstream object named outputFile and opens the Employees.txt file:

ofstream outputFile(“Employees.txt”);

Closing a File

The opposite of opening a file is closing it. Although a program’s files are automatically closed when the program shuts down, it is a good programming practice to write statements that close them. Here are two reasons a program should close files when it is finished using them:

• Most operating systems temporarily store data in a file buffer before it is written to a file. A file buffer is a small “holding section” of memory that file-bound data is first written to. When the buffer is filled, all the data stored there is written to the file. This technique improves the system’s performance. Closing a file causes any unsaved data that may still be held in a buffer to be saved to its file. This means the data will be in the file if you need to read it later in the same program.
• Some operating systems limit the number of files that may be open at one time. When a program closes files that are no longer being used, it will not deplete more of the operating system’s resources than necessary.

Calling the file stream object’s close member function closes a file. Here is an example:

inputFile.close();

Writing Data to a File

The program demonstrates an example that reads strings as input from the keyboard and then writes those strings to a file. The program asks the user to enter the first names of three friends, and then it writes those names to a file named Friends.txt. After this code has executed, we can open the Friends.txt file using a text editor and look at its contents.

// This program writes user input to a file.
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main()
{
    ofstream outputFile;
    string name1, name2, name3;

// Open an outputFile;
    outputFile.open("Friends.txt");

// Get the names of three friends.
    cout << "Enter the names of three friends.\n";
    cout << "Frind #1: ";
    cin >> name1;
    cout << "Frind #2: ";
    cin >> name2;
    cout << "Frind #3: ";
    cin >> name3;

// Where the names to the file.
    outputFile << name1 << endl;
    outputFile << name2 << endl;
    outputFile << name3 << endl;
    cout << "The names were saved to a file.\n";

// Close the file
    outputFile.close();
    return 0;
}

Reading Data from a File

The >> operator not only reads user input from the cin object, but also data from a file. Assuming inputFile is an ifstream object, the following statement shows the >> operator reading data from the file into the variable name:

inputFile >> name;

Let’s look at an example. The program below assumes the file Friends.txt exists, opens the file, reads the names and displays them on the screen, and then closes the file.

// This program reads data from a file.
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main()
{
    ifstream inputFile;
    string name;

inputFile.open("Friends.txt");
    cout << "Reading data from the file.\n";

inputFile >> name;          // Read name 1 from the line
    cout << name << endl;       // Display name 1

inputFile >> name;          // Read name 2 from the line
    cout << name << endl;       // Display name 2

inputFile >> name;          // Read name 3 from the line
    cout << name << endl;       // Display name 3

inputFile.close();          // Close the file
    return 0;
}

Using Loops to Process Files

Although some programs use files to store only small amounts of data, files are typically used to hold large collections of data. When a program uses a file to write or read a large amount of data, a loop is typically involved.

Quite often a program must read the contents of a file without knowing the number of items that are stored in the file. For example, suppose you need to write a program that displays all of the items in a file, but you do not know how many items the file contains. You can open the file and then use a loop to repeatedly read an item from the file and display it. However, an error will occur if the program attempts to read beyond the end of the file. The program needs some way of knowing when the end of the file has been reached so it will not try to read beyond it.

Fortunately, the >> operator not only reads data from a file, but also returns a true or false value indicating whether the data was successfully read or not. If the operator returns true, then a value was successfully read. If the operator returns false, it means that no value was read from the file.

There is a way to determine whether the open member function successfully opened the file. After you call the open member function, you can test the file stream object as if it were a Boolean expression.

In each of the previous examples, the name of the file that is opened is hard-coded as a 11 string literal into the program. In many cases, you will want the user to specify the name of a file for the program to open. In C++ 11, you can pass a string object as an argument to a file stream object’s open member function.

The program below shows an example. This version prompts the user to enter the name of the file. In line 15, the name that the user enters is stored in a string object named filename. In line 18, the filename object is passed as an argument to the open function.

The while Loop

The while loop has two important parts: (1) an expression that is tested for a true or false value, and (2) a statement or block that is repeated as long as the expression is true. The figure below shows the logic of a while loop.

Here is the general structure of the while loop:

In the general format, (expression) is any expression that can be evaluated as true or false, and statement; is any valid C++ statement. The first line shown in the figure above is called the loop header. It consists of the key word while followed by an expression enclosed in parentheses. Here’s how the loop works: the (expression) is tested, and if it is true, the statement(s) are executed. Then, the (expression) is tested again. If it is true, the statement(s) are executed. This cycle repeats until the (expression) is false. The statement(s) that is repeated is known as the body of the loop. The while loop works like an if statement that executes over and over. As long as the expression inside the parentheses is true, the body of the loop will repeat. The program below uses the while loop to print “Hello” five times.

// This program demonstrates a simple while loop.
#include <iostream>
using namespace std;

int main()
{
    int number = 0;

while (number < 5)
    {
        cout << "Hello\n";
        number++;
    }
    cout << "That's all!\n";
    return 0;
}

This program tests the variable number to determine whether it is less than 5. If it is, then the statements in the body of the loop are executed. The statement number++; in the body of the loop uses the increment operator to add one to number. This is the last statement in the body of the loop, so after it executes, the loop starts over. It tests the expression (number < 5) again, and if it is true, the statements in the body of the loop are executed again. This cycle repeats until the expression (number < 5) is false. Each repetition of a loop is known as an iteration. This loop will perform five iterations because the variable number is initialized with the value 0, and it is incremented each time the body of the loop is executed. When the expression (number < 5) is tested and found to be false, the loop will terminate and the program will resume execution at the statement that immediately follows the loop. The figure below shows the logic of this loop.

In this example, the number variable is referred to as the loop control variable because it controls the number of times that the loop iterates. The while loop is known as a pretest loop, which means it tests its expression before each iteration.

Infinite Loops

Loops must contain within themselves a way to terminate. This means that something inside the loop must eventually make the test expression false. The loop in the example above stops when the expression (number < 5) is false. If a loop does not have a way of stopping, it is called an infinite loop. An infinite loop continues to repeat until the program is interrupted. Here is an example of an infinite loop:

int number = 0;
while (number < 5)
{
    cout << "Hello\n";
}

This is an infinite loop because it does not contain a statement that changes the value of the number variable. Each time the expression (number < 5) is tested, number will contain the value 0. It’s also possible to create an infinite loop by accidentally placing a semicolon after the first line of the while loop.

int number = 0;
while (number < 5)
{
    cout << "Hello\n";  // This semicolon is an ERROR!
    number++
}

The semicolon at the end of the first line is assumed to be a null statement and disconnects the while statement from the block that comes after it. To the compiler, this loop looks like:

while (number < 5);

This while loop will forever execute the null statement, which does nothing. The program will appear to have “gone into space” because there is nothing to display screen output or show activity.

The do-while Loop

The do-while loop looks something like an inverted while loop. The figure below shows the logic of a do-while loop.

Here is the do-while loop’s structure when the body of the loop contains multiple statements:

The do-while loop is a posttest loop. This means it does not test its expression until it has completed an iteration. As a result, the do-while loop always performs at least one iteration, even if the expression is false to begin with. This differs from the behavior of a while loop, which you will recall is a pretest loop.

The for Loop

In general, there are two categories of loops: conditional loops and count-controlled loops. A conditional loop executes as long as a particular condition exists. For example, an input validation loop executes as long as the input value is invalid. When you write a conditional loop, you have no way of knowing the number of times it will iterate.

Sometimes you know the exact number of iterations that a loop must perform. A loop that repeats a specific number of times is known as a count-controlled loop. For example, if a loop asks the user to enter the sales amounts for each month in the year, it will iterate twelve times. In essence, the loop counts to twelve and asks the user to enter a sales amount each time it makes a count. A count-controlled loop must possess three elements:

1. It must initialize a counter variable to a starting value.
2. It must test the counter variable by comparing it to a maximum value. When the counter variable reaches its maximum value, the loop terminates.
3. It must update the counter variable during each iteration. This is usually done by incrementing the variable.

Count-controlled loops are so common that C++ provides a type of loop specifically for them. It is known as the for loop. The for loop is specifically designed to initialize, test, and update a counter variable. Here is the format of the for loop when it is used to repeat a block is:

The first line of the for loop is the loop header. After the key word for, there are three expressions inside the parentheses, separated by semicolons. (Notice there is not a semi- colon after the third expression.) The first expression is the initialization expression. It is normally used to initialize a counter variable to its starting value. This is the first action performed by the loop, and it is only done once. The second expression is the test expression. This is an expression that controls the execution of the loop. As long as this expression is true, the body of the for loop will repeat. The for loop is a pretest loop, so it evaluates the test expression before each iteration. The third expression is the update expression. It executes at the end of each iteration. Typically, this is a statement that increments the loop’s counter variable.

Here is an example of a simple for loop that prints “Hello” five times:

for (int count = 0; count < 5; count++)
{
    cout << "Hello" << endl;
}

In this loop, the initialization expression is count = 0, the test expression is count < 5, and the update expression is count++. The body of the loop has one statement, which is the cout statement. Figure below illustrates the sequence of events that takes place during the loop’s execution. Notice that Steps 2 through 4 are repeated as long as the test expression is true.

Notice how the counter variable, count, is used to control the number of times that the loop iterates. During the execution of the loop, this variable takes on the values 1 through 5, and when the test expression count < 5 is false, the loop terminates. Also notice that in this example the count variable is used only in the loop header, to control the number of loop iterations. It is not used for any other purpose. It is also possible to use the counter variable within the body of the loop. Because the for loop tests its test expression before it performs an iteration, it is a pretest loop.

Deciding Which Loop to Use

Each of the three C++ loops is ideal to use in different situations. Here’s a short summary of when each loop should be used.

• The while loop. The while loop is a conditional loop, which means it repeats as long as a particular condition exists. It is also a pretest loop, so it is ideal in situations where you do not want the loop to iterate if the condition is false from the beginning. For example, validating input that has been read and reading lists of data terminated by a sentinel value are good applications of the while loop.
• The do-while loop. The do-while loop is also a conditional loop. Unlike the while loop, however, do-while is a posttest loop. It is ideal in situations where you always want the loop to iterate at least once. The do-while loop is a good choice for repeating a menu.
• The for loop. The for loop is a pretest loop that has built-in expressions for initializing, testing, and updating. These expressions make it very convenient to use a counter variable to control the number of iterations that the loop performs. The initialization expression can initialize the counter variable to a starting value, the test expression can test the counter variable to determine whether it holds the maximum value, and the update expression can increment the counter variable. The for loop is ideal in situations where the exact number of iterations is known.

Optional Topics: Breaking and Continuing a Loop

Sometimes it’s necessary to stop a loop before it goes through all its iterations. The break statement, which was used with switch in Chapter 4, can also be placed inside a loop. When it is encountered, the loop stops, and the program jumps to the statement immediately following the loop.

The while loop in the following program segment appears to execute 10 times, but the break statement causes it to stop after the fifth iteration.

int count = 0;
while (count++ < 10) 
{
    cout << count << endl;
    if (count == 5)
        break;
}

Using break in a Nested Loop

In a nested loop, the break statement only interrupts the loop it is placed in. The following program segment displays five rows of asterisks on the screen. The outer loop controls the number of rows, and the inner loop controls the number of asterisks in each row. The inner loop is designed to display 20 asterisks, but the break statement stops it during the eleventh iteration.

for (int row = 0; row < 5; row++) 
{
    for (int star = 0; star < 20; star++)
    {
        cout << ‘*’;
        if (star == 10)
            break;
    }
    cout << endl;
}

The continue Statement

The continue statement causes the current iteration of a loop to end immediately. When continue is encountered, all the statements in the body of the loop that appear after it are ignored, and the loop prepares for the next iteration.

In a while loop, this means the program jumps to the test expression at the top of the loop. As usual, if the expression is still true, the next iteration begins. In a do-while loop, the program jumps to the test expression at the bottom of the loop, which determines whether the next iteration will begin. In a for loop, continue causes the update expression to be executed and then the test expression to be evaluated.

The following program segment demonstrates the use of continue in a while loop:

int testVal = 0;
while (testVal++ < 10)
{
    if (testVal == 4) 
        continue;
    cout << testVal << “ “;
}

This loop looks like it displays the integers 1 through 10. When testVal is equal to 4, however, the continue statement causes the loop to skip the cout statement and begin the next iteration. The output of the loop is

1 2 3 5 6 7 8 9 10

The if/else Statement

The if/else statement will execute one group of statements if the expression is true, or another group of statements if the expression is false. The if/else statement is an expansion of the if statement. Here is its format:

If the (expression) is true, a statement or block of statements is executed. If the (expression) is false, a separate group of statements is executed. Note that the program will only take one of the two paths in the if/else statement. If you think of the statements in a computer program as steps taken down a road, consider the if/else statement as a fork in the road. Instead of being a temporary detour, like an if statement, the if/else statement causes program execution to follow one of two exclusive paths.

Nested if statements

To test more than one condition, an if statement can be nested inside another if statement. Sometimes an if statement must be nested inside another if statement. For example, consider a banking program that determines whether a bank customer qualifies for a special, low interest rate on a loan. To qualify, two conditions must exist: (1) the customer must be currently employed, and (2) the customer must have recently graduated from college. The figure blow show’s how a nested if statement would be coded for the banking program:

The if/else if Statement

The if/else if statement tests a series of conditions. It is often simpler to test a series of conditions with the if/else if statement than with a set of nested if/else statements.

When the statement executes, (expression_1) is tested. If (expression_1) is true, the block of statements that immediately follows is executed, and the rest of the structure is ignored. If (expression_1) is false, the program jumps to the very next else if clause and tests (expression_2). If it is true, the block of statements that immediately follows is executed, and then the rest of the structure is ignored. This process continues, from the top of the structure to the bottom, until one of the expressions is found to be true. If none of the expressions are true, the last else clause takes over, and the block of statements immediately following it is executed. The last else clause is referred to as the trailing else. The trailing else clause, which appears at the end of the if/else if statement, is optional, but in many situations you will use it to catch errors.

The if/else if Statement Compared to a Nested if Statement

You never have to use the if/else if statement because its logic can be coded with nested if/else statements. However, a long series of nested if/else statements has two particular disadvantages when you are debugging code:

• The code can grow complex and become difficult to understand.
• Because indenting is important in nested statements, a long series of nested if/else statements can become too long to be displayed on the computer screen without horizontal scrolling. Also, long statements tend to “wrap around” when printed on paper, making the code even more difficult to read.

The logic of an if/else if statement is usually easier to follow than that of a long series of nested if/else statements. And, because all of the clauses are aligned in an if/else if statement, the lengths of the lines in the statement tend to be shorter.

The Conditional Operator

You can use the conditional operator to create short expressions that work like if/else statements. The conditional operator is powerful and unique. It provides a shorthand method of expressing a simple if/else statement. The operator consists of the question-mark (?) and the colon (:). Its format is:

Here is an example of a statement using the conditional operator:

x < 0 ? y = 10 : z = 20;

The conditional expression above performs the same operation as the following if/else statement:

if (x < 0)
  y = 10;
else
  z = 20;

The part of the conditional expression that comes before the question mark is the expression to be tested. It’s like the expression in the parentheses of an if statement. If the expression is true, the part of the statement between the ? and the : is executed. Otherwise, the part after the : is executed. Figure below illustrates the roles played by the three sub-expressions.

If it helps, you can put parentheses around the sub-expressions, as in the following:

(x < 0) ? (y = 10) : (z = 20);

The switch Statement

The switch statement lets the value of a variable or expression determine where the program will branch. A branch occurs when one part of a program causes another part to execute. The if/else if statement allows your program to branch into one of several possible paths. It performs a series of tests (usually relational) and branches when one of these tests is true. The switch statement is a similar mechanism. It tests the value of an integer expression and then uses that value to determine which set of statements to branch to. Here’s the structure of the switch statement:

The first line of the statement starts with the word switch, followed by an integer expression inside parentheses. This can be either of the following:

• a variable of any of the integer data types (including char)
• an expression whose value is of any of the integer data types

On the next line is the beginning of a block containing several case statements. After the word case, is a constant expression followed by a colon. The constant expression may be an integer value or an integer named constant. The case statement marks the beginning of a section of statements. The program branches to these statements if the value of the switch expression matches that of the case expression. An optional default section comes after all the case statements. The program branches to this section if none of the case expressions match the switch expression. So, the defaults section is like a trailing else in an if/else if statement.

Here is an example of a switch statement:

// The switch statement in this program tells the user the data just
// entered
#include <iostream>
using namespace std;

int main()
{
    char choice;

cout << "Enter A, B, or C: ";
    cin >> choice;
    switch (choice)
    {
        case 'a':
        case 'A': cout << "You entered A.\n";
                  break;
        case 'b':
        case 'B': cout << "You entered B.\n";
                  break;
        case 'c':
        case 'C': cout << "You entered C.\n";
                  break;
        default:  cout << "You did not enter A, B, or C!\n";
    }
    return 0;
}

The case statements show the program where to start executing in the block and the break statements show the program where to stop. Without the break statements, the program would execute all of the lines from the matching case statement to the end of the block.

// This program demonstrates values stored in true and false
#include <iostream>
using namespace std;

int main()
{
  bool boolValue;
  boolValue = true;
  cout << boolValue << endl;
  boolValue = false;
  cout << boolValue << endl;
  return 0;
}

If you were to demo this program you would see that those two abstract states are converted to numbers. In C++, relational expressions represent true states with the number 1 and false states with the number 0.

In the world of the if statement, however, the concept of truth is expanded. 0 is still false, but all values other than 0 are considered true. This means that any value, even a negative number, represents true as long as it is not 0. Just as in real life, truth is a complicated thing. Here is a summary of the rules you have seen so far:

• When a relational expression is true it has the value 1.
• When a relational expression is false it has the value 0.
• Any expression that has the value 0 is considered false by the if statement. This includes the bool value false, which is equivalent to 0.
• Any expression that has any value other than 0 is considered true by the if statement. This includes the bool value true, which is equivalent to 1.

The fact that the if statement considers any nonzero value as true opens many possibilities. Relational expressions are not the only conditions that may be tested. For example, the following if statement in C++ are legal:

if (value)
  cout << "It's True";

The if statement above does not test a relational expression, but rather the contents of a variable. If the variable’s value contains any number other than 0, the message “It’s True” will be displayed. If value is 0, the cout statement will be skipped.

if (x + y)
  cout << "It's True";

In this statement the sum of x and y is tested like any other value in an if statement: if the sum is 0, then it’s false. If the sum is any other values, then it’s true. You may also use the return value of function calls as conditional expressions.

if (pow(a, b))
  cout << "It's True";

This if statement uses the pow function to raise a to the power of b. If the result is anything other than 0, the cout statement is executed. This is a powerful programming technique that you can use for evaluating conditionals as in determining the range of a variable, selecting through menu options, and flagging errors in your program.

What happens when an int is multiplied by a float, what data type will the result be? What about a double divided by an int? Is there a way to predict which data type will be assigned to the result? The answer is yes, C++ follows a set of rules when performing mathematical operations on variables of different data types. Just like officers in the military, data types are ranked too. One data type outranks another if it can hold a larger number. For example, a double outranks a float, and a float outranks an int. The table below list the data types in order of their rank, from highest to lowest.

One exception to the ranking in the table is when an int and a long are the same size. In that case, an unsigned int outranks long because it can hold a higher value. When a value is converted to a higher data type, it’s known as promoted. To demote a value means to convert it to a lower data type. Let’s look at some specific rules that dictate the evaluation of mathematical expressions.

Rule 1: chars, shorts, and unsigned shorts are automatically promoted to int.

You will notice that char, short, and unsigned short do not appear in the table. That’s because anytime they’re used in a mathematical expression, they’re promoted to an int. The only exception to this rule is when an unsigned short holds a value larger than can be held by an int. This can happen on systems where a short is the same size an int. In this case, the unsigned short is promoted to unsigned int.

Rule 2: When an operator works with two different data types, the lower-ranking value is promoted to the type of the higher-ranking value.

In the following expression, assume that length is an int and width is a float:

length * width

Before the multiplication take place, length will be promoted to a float.

Rule 3: When the final value of an expression is assigned to a variable, it will be converted to the data type of that variable.

In the following statement, assume that area is a double, while length and width are both floats:

area = length * width

Since length and width are both floats but area is a double, the result from the multiplication will be convert to a double because area was initialized as a double.

Watch out for situations where an expression results in a fractional value being assigned to an integer variable. Here is an example:

int x, y = 4; 
float z = 2.7; 
x = y * z;

In the expression y * z, y will be promoted to float and 10.8 will be the result from the multiplication. Since x is an integer, however, 10.8 will be truncated and 10 will be stored in x.

When you divide an integer by another integer in C++, the result is always an integer. If there is a remainder, it will be discarded. For example, in the following code, parts is assigned the value 2.0:

double parts;
parts = 15 / 6;

Even though 15 divided by 6 is really 2.5, the .5 part of the result is discarded because we are dividing an integer by an integer. It doesn’t matter that parts was initialized as a double because the decimal part of the result was discarded before the result was assigned to parts. In order for a division operation to return a floating-point value, at least one of the values must be a floating-point data type. For example, the previous code could be written as:

double parts; 
parts = 15.0 / 6;

In this code the value 15.0 is interpreted as a floating-point number, so the division operation will return a floating-point number. The value 2.5 will be assigned to parts.

Keyboard shortcuts for text:
⌘ + ↩ (command + return) will insert line after
⌘ + ⇧ + ↩ (command + shift +return) will insert line before
⌘ + ⌃ + ↑ (command + control + down) will move current line up
⌘ + ⌃ + ↓ (command + control + up) will move current line down
⌘ + Left (command + left-arrow) will move to beginning of text on line to
⌘ + Right (command + rigth-arrow) will move to end of line
⌘ + L (command + L) will select(highlight) current line. (p.s. multiple command entries will select the line below too)
⌘ + D (command + D) will select(highlight) current word. (p.s. multiple command entries will select recurrences of the selected word)
⌘ + ] (command + ]) will indent the current line
⌘ + [ (command + [) will un-indent the current line
⌘ + ⇧ + D (command + shift + D) will dupilcate the current line below
⌘ + K, ⌘ + K (command + K, command + K) will delete from cursor to end line

These keyboard shortcuts are associated tabs:
⌘ + ⇧ + [ (command + shift + ]) will go to the tab left of the open tab
⌘ + ⇧ + ] (command + shift + [) will go to the tab right of the open tab