Q: Function to merge 2 lists of numbers and order them from least to greatest? I have to create a function that will take 2 input streams and an output stream. The function is supposed to read a list of integers from 2 separate files, merge that list, order the numbers from least to greatest, then output this consolidated and ordered list onto a new file. 
Here's the code for the function:
void merge(ifstream& inStream1, ifstream& inStream2, ofstream& outStream)
{
    int arr[100], i = 0;

    while(!inStream1.eof())
    {
        inStream1>>arr[i++];
    }

    while(!inStream2.eof())
    {
        inStream2>>arr[i++];
    }

    int indexOfNextSmallest;
    for (int index = 0; index < i - 1; index++)
    {
        indexOfNextSmallest = indexOfSmallest(arr, index, i);
        swapValues(arr[index], arr[indexOfNextSmallest]);
    }

    for (int index = 0; index < i; index++)
    {
        outStream<<arr[index]<<endl;
    }
}

int indexOfSmallest(const int arr[], int startIndex, int i)
{
    int min = arr[startIndex], indexOfMin = startIndex;

    for (int index = startIndex + 1; index < i; index++)
    {
        min = arr[index];
        indexOfMin = index;
    }
    return indexOfMin;
}

void swapValues(int& v1, int& v2)
{
    int temp;
    temp = v1;
    v1 = v2;
    v2 = temp;
}

Here's a sample input output:
file 1 has these numbers: 
4
5
8
11
18
28 

file 2 has these numbers:
87
234
11
8
9
45
23

This outputs to the new file:
23
4
5
8
11
18
28
1988923808
87
234
11
8
9
45

I'm totally lost. Please help me fix this. Thanks.

A: int arr[100]

Why? Do you know that there won't be more than 100 elements in both files, combined? Probably not, right?
So you better use a data structure that can dynamically adapt it's size, like a std::vector. But, since you also seem to want to remove duplicates, a std::set is the better choice. This gives you another bonus: The elements of a std::set are sorted.
This way, your problem reduces to:
void merge(std::istream & in1, std::istream & in2, std::ostream & out) {
 // The set is used to store the elements from both files.
 // Since it also sorts them, no explicit sorting is needed.
 // Duplicates will be removed, if that's not what you want, use a multiset
 std::set<int> storage;
 // The istream_iterator applies operator>> to the whole file, effectively
 // reading the whole file contents.
 storage.insert(
   std::istream_iterator<int>(in1),
   std::istream_iterator<int>());
 storage.insert(
   std::istream_iterator<int>(in2),
   std::istream_iterator<int>());
 // We copy each element of the set (they're in sorted order) into
 // the output. Using the ostream_iterator, it's like writting
 // for (auto element : storage) { out << element << " "; }
 std::copy(
   std::begin(storage), std::end(storage),
   std::ostream_iterator<int>(out, " ")); // if you want seperate lines use "\n"
}

With your input and this code I get:
4 5 8 9 11 18 23 28 45 87 234 

Use what the standard library provides you!

Concerning your code:
int indexOfSmallest(const int arr[], int startIndex, int i)
{
    int min = arr[startIndex], indexOfMin = startIndex;

    for (int index = startIndex + 1; index < i; index++)
    {
        min = arr[index]; /* HERE */
        indexOfMin = index;
    }
    return indexOfMin;
}

You don't look, whether the current element (at index) is actually smaller than the current minimum!
// inside that loop
if (arr[index] < min) {
 min = arr[index];
 indexOfMin = index;
}

(Of course, there's also std::min_element.)
Oh, and:
void merge(ifstream & //...

Don't hard code requirements that you do not have. You don't need file streams here, just streams, so istream and ostream are better choices.
And also:
while(!inStream1.eof())
{
    inStream1>>arr[i++];
}

Consider the file containing a text string hello. Then your stream will fail, but you continue to read input. Better test directly on the input operation:
while (inStream1 >> arr[i++]);

