Payroll program

First, you are using namespace std;. This is not usually a good idea because if you use more than one namespace, you may have functions that have the same name, and the compiler will not know which to use. More information can be found here.

Another potential problem is that you have a fair amount of global variables. You should keep your variables to as tight a scope as possible, so I would recommend creating at least some of these in main() and passing them to other functions as needed.

getEmployeeInfor(); should be getEmployeeInfo(); as info is the accepted abbreviation for information (it even passes my spell check).

You are using redundant comments:

// Get employee information
getEmployeeInfor();

Your naming is very good, and you don't need to say in a comment what you are clearly saying in your code.

Your indentation is a bit off:

void getEmployeeInfor()

{
 cout << "Please enter your employee id, payrate, and hours worked: " << endl;
 cin >> id >> payRate >> hours;

 //Loop to check for valid numbers.
   while ((id < 0) || payRate < 0 || hours < 0)
  {
   cout << "Please enter valid values (Positive numbers): " << endl;
   cin >> id >> payRate >> hours;
  }
}

The standard indentation (usually) is 4 spaces. I would write this like this:

void getEmployeeInfo()
{
    std::cout << "Please enter your employee id, pay rate, and hours worked:\n";
    std::cin >> id >> payRate >> hours;

    //Loop to check for valid numbers.
    while (id < 0 || payRate < 0 || hours < 0)
    {
        std::cout << "Please enter valid values (Positive numbers):\n";
        std::cin >> id >> payRate >> hours;
    }
}

I cleaned the indentation and spacing up, I removed unnecessary braces from the while conditions, I specified that I am using the std namespace, and I changed the << endl section in the output to the newline character \n because you are using a string anyway.

Most of your other methods have indentation problems, but you should be able to clean them up using these tips.

void repeat()
{  
  char answer;
  cout << "Would you like to continue entering values? (y/n): ";
  cin >> answer;
  if (answer == 'y'|| answer == 'Y')
  {
    getEmployeeInfor();   // gets employee information
    wage = calcWage();    // calculates wage
    printWages();         // prints wage to the outputfile
    // calls repeat function again;
     repeat();
   }
  else
   {
    // Close the outputfile
    outputFile.close();
    cout << file << " was closed succesfully" << endl;
   }
}

This approach is extraordinarily problematic.

Open up any program that can report on the amount of memory your system's processes are consuming and start observing how much RAM is required by your application as you repeatedly answer y to the question your repeat() function asks.

This is unintended recursion you've got going on here. Each time we repeat(), our program consumes more and more RAM because we have to add another copy of all of these functions and all of their local variables to the stack. Eventually, depending on how much RAM your machine has and how bored you are, you can get this program to run into a Stack Overflow exception.

This isn't a memory leak. All of the memory will be appropriate released. It's not trapped anywhere and forgotten about. It's just that the application is designed in such a way that it consumes far more memory than it needs.

Moreover, this approach results in some code duplication.

Instead, perhaps we need a while or dowhile loop? Let's change the repeat() function to return a bool and simply determine whether or not the user wants to continue without actually doing anything:

bool repeat()
{
    char answer;
    cout << "Would you like to continue entering values? (y/n): ";
    cin >> answer;
    return (answer == 'y' || answer == 'Y');
}

Now let's rewrite main(), shall we?

int main() 
{
    cout << "Please enter the name of the file you wish to save to: ";
    cin >> file;
    outputFile.open(file.c_str());

    do {
       // Get employee information
       getEmployeeInfor();
       // Calculate the total wage
       wage = calcWage();
       // Prints the Table to the outputFile
       printTable();   
       // Prints the  wages to the output File
       printWages();
    } while(repeat());

    // Close the outputfile
    outputFile.close();
    cout << file << " was closed succesfully" << endl;

    read();

    return 0;
}

This has the added benefit of closing the file in the same context in which it is opened (it's a massive red-flag otherwise--though we should really only open just before we need to read/write and close immediately after we've finished). Moreover, the flow of the program makes a lot more sense now. And we've eliminated some duplicated code... and that nasty unseen RAM problem.

// Function for calculating the Wage
double calcWage()
{
  double wages;
  return wages = payRate * hours;
}

There's no point in declaring a variable and assigning to it:

double calcWage() {
    return payRate * hours;
}

Or even better:

double calcWage(double payRate, double hours) {
    return payRate * hours;
}

You have basically no error checking. File opening, stream token extraction, and file closing can all fail.

In fact:

outputFile.close();
cout << file << " was closed succesfully" << endl;

That's a lie. If close() fails, it sets the failbit but otherwise does nothing. It's completely possible that flushing out some cached stuff failed and the the full content of the file didn't make it to disk.

    inputFile.open(file.c_str());
    while (!inputFile.eof())
     {
       getline(inputFile, strings);
       cout << strings<< endl;
     }

This is wrong. It will actually 'read' an extra line erroneously since eof() doesn't return true until an attempt has been made to read past the end of the stream. The idiomatic way to do this would be:

for (std::string line; std::getline(inputFile, line); ) {
    std::cout << line << '\n';
}
// Maybe followed by a std::cout << std::flush depending on situation

Or, better yet, there's no point to read the stream line by line just to output it line by line again. You can just copy the stream to std::cout with std::cout << inputFile.rdbuf();. (Note that this does have very slightly different semantics since it's a binary copy instead of a character stream.)

Functions should be responsible for one discrete responsibility, but this is broken in a few places. For example, read(): 1) prompts for user input, 2) opens a file, 3) copies the file to cout, 4) closes the file, 5) terminates the program.

That's a lot of things for one function to be doing. Main should handle the exiting (since it's responsibility is to oversee the flow of the program execution), and instead of opening and closing a file, read should be passed an already open file.

strings has no reason to be global, and it should be called line, especially since it's a single string, not a collection of them.

inputFile should not be global. It's not necessary for it to global since every function that uses it immediately closes it. Even better, since you're not actually explicitly checking if the file closes successfully (and really, it'd be fairly overkill to do that unless you're making a very robust program), if you use a local variable, it will close itself automatically.

void doSomethingWithAFile() {
    std::ofstream os("some file name");
    // Do something with the file
} // File automatically closes when os is destructed

Side note: This is actually a veiled peak at RAII, or the concept that resource life times should be tied to object life times (over simplified, but yeah). It's probably a bit early at this point to go reading into that too much, but once you're deeper into C++ (perhaps when you find yourself becoming fairly comfortable with the object model), make sure you look it up at some point.

This has already been said before by someone else, but just to reiterate, don't use globals. Just don't. At least not until you come across your first situation where you truly cannot do anything else (and it's possible to go years in between those situations). To be a bit dramatic, globals go against pretty much every software design principle there is.

Your program can very easily eliminate globals by using local variables in main and passing parameters to functions as needed. I know in an example program this simple and small it doesn't seem like it really makes a difference (it might even seem more cumbersome), but it really is a habit you should get out of. In large or complex systems, globals can quickly turn into a a testability killer and become Petri dishes for weird, hard to find bugs.

(Note: immutable globals [usually called constants] don't have nearly as big of set of problems [though they still have their own set of problems]. If you actually heed my end-of-the-world-warning about globals, just know that you can chill out a bit towards constants as long as you're sure to be mindful of if/when they become determinant to the quality of the application.)