Naming things

I would avoid using exactly the same name as the function from the standard library. Yours does a bit more. Maybe get_values_from_line() or get_line_values() would be better.

Avoid unnecessary abbreviations, or if you do, use commonly used ones. So instead of meas write measurements (or perhaps just result), and instead of linei write line_iterator or line_it.

lines sounds like it is the plural of line, but it still is just a single line. Maybe this is an abbreviation of line_stream?

Pass a std::istream instead of a std::ifstream

Your getline() function doesn't care whether the stream is a file or any other kind of stream. So make it take a reference to a std::istream. That way, something like this will also compile:

auto values = sf::io::getline<double>(std::cin);

Opportunities to improve performance

The way you wrote the code, after reading in a line into a string, you copy that string into a string stream object. It's better to move it:

std::istringstream line_stream{std::move(line)};

Next, you are creating a stream iterator that returns strings, and then you call std::stod() to convert those strings to T. But why not let the stream iterator return Ts instead?

std::istream_iterator<T> line_it{lines};

std::copy(line_it,
    std::istream_iterator<T>{},
    std::back_inserter(measurements)
);

Error handling

Unfortunately, many things can go wrong when doing I/O: there might be a read error reading a file, or the file may contain something that is not just correctly formatted numbers. You should make your code robust against all these things, and instead of returning a std::vector that contains nonsense, make sure you return an error to the caller somehow.

The first issue is that data.eof() wil return false if an error occurs before reaching the actual end of the file. Subsequent calls to std::getline() will likely not fix the error, so the while-loop will then become an infinite loop. The best thing to do is check for data.good():

while (data.good() && !line.empty) {
    std::getline(data, line);
}

Then, consider that std::istream_iterator may encounter errors as well. If that happens, check lines.good(). If it returns false, then you know that the line was not read correctly.

There are various options for handling errors:

• throw an exception, preferrably a std::runtime_error or something derived from it.
• Return a std::expected if you can use C++23.
• Create a new class that holds the result and an error code, like std::from_chars() does.

You could also return an empty vector, as normally you ignore empty lines and that would thus be an unexpected output. However, that is too easy to ignore in the rest of your code.

Make it more generic

I already mentioned using a reference to a std::istream instead of std::ifstream, this makes the code usable in many more situations. But once you use std::istream_iterator<T>, you'll notice that you can put in any type that operator>>() supports. So if you want a vector of chars or std::strings, that will now also work. Consequently, the constraint that T is Arithmetic is more narrow than necessary.

Also consider that you might not want to store the results in a std::vector, but rather in a std::deque, std::list or some other container. It would be nice if you could avoid hardcoding the result type. The best way would be to make your function return a view of the elements of type T of a single line, and then the caller can do whatever they want with that. Consider being able to write:

auto values = sf::io::get_line_view<double>(file) | std::ranges::to<std::vector>();

Or perhaps the caller didn't want to store it in a container anyway, but just iterate over the values, then they could write:

for (auto value: sf::io::get_line_view<double>(file)) {
    …
}

One way to do this without too much effort is by using C++23's std::generator:

template<typename T>
std::generator<const T&> get_line_view(std::istream& input) {
    …
    std::istream_iterator<T> begin(line_stream), end();

    for (auto it = begin; it != end; ++it) {
        co_yield *it;
    }
}