Cpp Get File Line by Index

I have a C++ program which reads a specific line from a file based on the index of that line. The index is calculated elsewhere in the program. My question is: can I open a file (i.e., a .txt) and read a line specified by its index?

So far, I have the following code:

#include <iostream>
#include <fstream>

std::string getLineByIndex(int index, std::fstream file)
{
  int file_index = 0;
  std::string found_line;
  for( std::string line; std::getline(file, line); )
  {
      if (index == file_index)
      {
          found_line = line;
          break;
      }
      file_index++;
  }

  return found_line;
}

This linear search will of course become less efficient as the number of lines in the file scales. Therefore, is there a more efficient way to read a line from a file using its index? Does the answer change if each line in the file is the exact same length?

Files have no indexes. There are offsets though. They can be thought of as indexes, but they "index" not the lines, but certain bytes. If the line length is known and fixed, you can calculate the offset at which the searched line is located, move the "cursor" at this offset, and read it with one operation. I do not know how this works in C++, but in C you will use lseek for file descriptors, and fseek for FILE structures. I'd suggest reading on file offset manipulation in iostreams, or use stdio.h.

Basically, if the line length is 10 and you need 3rd line you will move offset at 10 * 3 and read 10 bytes. You should also factor in the file contents. If there are cyrillic letters, for example, then offset might point at the certain bytes in one letter, which makes the task more difficult.

If line length is not fixed:

If you do this fetching of lines from one particular file often, I suggest reading file in it's entirety into the memory, provided the file is not too big, placing the lines into the vector. Or you can mmap the file - this is pretty much the same.

Or, if the file is big, and you need to access it's lines often, I'd suggest caching each fetch operation. Basically - read a file, got a line - place it's somewhere if you will need it later.

Overall, the best solution depends on what exactly you want to achieve. Is the file big? How often will the file be read? Is there only one file, or several files? Is the line length fixed?

But I think that your current solution is probably the most sane. Not too difficult, just read the lines in the loop.