How to copy a string to an element of array of pointers?

Why yours doesn't work:

getline (*ioFile, *content[i]);  //this is the tricky part
                 ^^^
// You have an extra dereference above

It should just be:

getline (*ioFile, content[i]);

How you should do it:

std::ifstream f(filename);
std::vector<std::string> lines;
for(std::string temp; std::getline(f, temp); lines.push_back(std::move(temp)));

Note: there is no cleanup required here. The ifstream closes itself. The vector deletes what it allocates. This is much smaller more efficient code to get the lines of a file as strings.

Use a deque<string> instead. You'll avoid a whole lot of pain, including the need to read the file twice:

void Document::loadFile(string iFileExt){
    if (ifstream fin(iFileExt)) {
        string row;
        deque<string> content;

        while(getline(fin, row))
            content.push_back(row);

        // Do something with content.
    } else {
        cerr << "File failed to open for read" << endl;
        exit(69);
    }
}

Note: In C++11 — due to move semantics — it might be better to use vector<string> and push_back(move(row)), though I/O will probably swamp the difference.

EDIT: If you really need pointers to strings, the above approach works equally well with minor changes:

        deque<string *> content;

        while(getline(fin, row))
            content.push_back(new string(row));

This is a bad, bad idea, however. At the very least, you should use smart pointers. In C++11, this is easy:

        vector<shared_ptr<string>> content;

        while(getline(fin, row))
            content.push_back(make_shared<string>(move(row)));

void Document::loadFile(string iFileExt)
{
  ioFile = new fstream(iFileExt.c_str(), ios::in); // does this ever get deleted?
  // string *content; // arrays have their place, and this is not it
  std::vector<string> content;

  if (ioFile->fail()){
    cerr << "File failed to open for read" << endl;
    exit(69); // don't ever just unconditionally exit from random places
              // it makes for unmaintainable spaghetti code
  }

  for (int i = 0; ioFile->good(); ++i) // loop manages i for us
  {
    content.push_back((string()));
    getline (*ioFile, content[i]);
  }

  ioFile->close();
}

The following might be useful when replacing the existing code, which uses an array of pointers, to something that takes a vector.

The function probably has a signature something like this:

void ProcessLinesInFile(int numLines, std::string *lines[]); // maybe this
void ProcessLinesInFile(int numLines, std::string **lines);  // or maybe this

Both ways are essentially equivalent. ProcessLinesInFile probably has a body something like this:

for (int i = 0; i < numLines; ++i)
{
    *lines[i] = Process(*lines[i]); // read and maybe write the line
}

The first step would be to make it work with an array of strings, rather than an array of string pointers:

void ProcessLinesInFile(int numLines, std::string lines[])
{
    // should behave exactly the same way as before
    for (int i = 0; i < numLines; ++i)
    {
        lines[i] = Process(lines[i]); // read and maybe write the line
    }
}

From there, using a vector is easy:

void ProcessLinesInFile(std::vector<std::string> &lines)
{
    // should behave exactly the same way as before
    for (int i = 0; i < lines.size(); ++i)
    {
        lines[i] = Process(lines[i]); // read and maybe write the line
    }
}

If you're sure that you never need to actually change the array throughout this process, you can (and it is prudent to) pass the vector reference as a constant:

void ProcessLinesInFile(std::vector<std::string> const &lines);