How to make a C++ wrapper to provide file and line information for a std::vector out of range message on terminal and abort

How to make a C++ wrapper to provide file and line information for a std::vector out of range message on terminal and abort?

I wrote the attached code, which does the job, but needed the extra template R, which is used to output the result that to get it to compile.

Two questions :-

1. Is there any way avoid using a MACRO to get the file and line info passed so it can be output?

2. Is there a way to change it so I could change so the function returns the item? ie std::string s = vec_get(v, idx);

This is the current output, which is clearer than just the stl_vector.h _M_range_check output (this is the STL library)

$ ./vec_throw2
vec_throw2.cpp:69 err std::vector 0 out of range size 0
terminate called after throwing an instance of 'std::out_of_range'
what():  vec_get
Aborted (core dumped)



The code follows

// g++ -Wall -O2 -o vec_throw vec_throw2.cpp
#include <vector>
#include <cstdio>
#include <stdexcept>

using namespace std;

template<class T, class R>
void vec_get(T v, R r, size_t idx, const char * const file, const int line)
{
    if (idx<v.size())
    {
        r = v.at(idx);
    }
    else
    {
        printf("%s:%d err std::vector %zu out of range size %zu\n", file, line, idx, v.size());
        throw std::out_of_range ("vec_get");
    }
}

#define VEC_GET2(v, w, idx) vec_get(v, w, idx, __FILE__, __LINE__)

int main()
{
    std::vector<std::string> v;

    int ret = 0;
    size_t idx = 0;

    std::string s;
    VEC_GET2(v, s, idx);
    return ret;
}

I experimented with some different ways, including 'auto' return.

Using std::source_location and just checking the bounds once:

#include <iostream>
#include <source_location>
#include <stdexcept>
#include <vector>

template <class T, class R>
void vec_get(T v, R& r, size_t idx, // take r by reference
             const std::source_location loc = std::source_location::current()) {
    try {
        r = v.at(idx); // only one bounds check
    } catch (...) {
        // If you use `printf` you may need to `std::fflush(stdout)` to see your
        // message. Use `fprintf(stderr, ...` or `std::cerr` instead.
        std::cerr << loc.file_name() << ':' << loc.line() << " err std::vector "
                  << idx << " out of range size " << v.size() << '\n';
        throw;  // rethrow the original exception
    }
}

int main() {
    std::vector<std::string> v;
    size_t idx = 0;
    std::string s;

    vec_get(v, s, idx);

    std::cout << s << '\n';
}

Possible output:

example.cpp:23 err std::vector 0 out of range size 0
terminate called after throwing an instance of 'std::out_of_range'
  what():  vector::_M_range_check: __n (which is 0) >= this->size() (which is 0) 

In c++20 you can use std::source_location. Though afaik only gcc supports it. Then you do not need the macro.

Actually I don't know what issue you encountered with returning the element. You can just do it

#include <vector>
#include <iostream>
#include <stdexcept>
#include <source_location>
		
using namespace std;

template<class V>
auto vec_get(V v, size_t idx, std::source_location loc = std::source_location::current()) {
    if (idx >= v.size()) {
        std::cout << loc.file_name() << " " 
                  << loc.line() << " "
                  << idx << " " 
                  << v.size() << std::endl;
        throw std::out_of_range ("vec_get");
    }
    return v[idx];
}

int main() {
    std::vector<std::string> v;

    int ret = 0;
    size_t idx = 0;

    std::string s = vec_get(v, idx);
    return ret;
}

Live Demo

As mentioned in comments, once you checked that the index is valid and throw your own exception there is no point in calling at. Also you have to make sure to flush the stream before throwing the exception if you want to see output also when the program terminates.

However, I do allow myself to question your approach. Instead of getting used to try accessing element via invalid index, you should rather make sure that indices are valid before actually trying to access the element. It is really rare that you cannot do that. From the top of my head the only instance I can imagine is when the index is from external input. And in this case you would implement some sanity checks on the input rather than relying on the container to throw some out_of_range error that tells nothing about the root cause.

On the other hand, there are many cases where you do not want bounds checking. For example it would be a waste in a loop iterating the elements:

for (int i=0; i < v.size(); ++i) vec_get(v,i); // please no!