C++ Get reference of object inside vector using function - c++

Question

Can you get a reference to an object that is within a vector through a function? I could do this with pointers easily, but you know, we're all obsessed here with "Don't use pointers".
This is a simple example. The absolute limitation is it must be done from a function call (so that function call can return false if not found).
// Example program
#include <iostream>
#include <string>
#include <vector>
class Dev {
public:
Dev(){}
std::string name;
};
void geter(std::vector<Dev> &devs, Dev &a){
a = devs.at(0);
}
int main()
{
Dev d;
d.name = "original name";
std::vector<Dev> devs;
devs.push_back(d);
Dev a;
geter(devs, a);
a.name = "new name";
std::cout << d.name; // still prints "original name"
}

Answer 1

Can you get a reference to an object that is within a vector through a function?
Yes, but you cannot return that reference via a function parameter. A reference can be bound to an element only at the point of initializing the reference. Once you are inside a function, it is too late to initialize the function's parameters, too late to bind a reference. You can return a reference via a function's return value, but not via an output parameter.
References also fail to cover the "not found" possibility, as a reference must be bound to something.
The language feature that allows the functionality you are looking for is called a "pointer".
References are useful if they can be bound during initialization, never need to change what they are bound to, and never need to be in a state of not being bound. The first parameter to your geter function is an example of this.
Pointers are useful if they need to point to different objects during their lifetime, or if they might need to be in an "unbound" state (a.k.a. be null). Think of a pointer as a reference that can be reseated (refer to a different object than it did before) and that can be unseated (refer to no object). The intended functionality of the second parameter to your geter function is an example of this.
I could do this with pointers easily,
Good. You know the right tool for the job. Do it.
but you know, we're all obsessed here with "Don't use pointers".
No, I do not know that. In fact, that is bad advice when stated that broadly. Pointers still have their place in modern C++. The "obsession" you probably are referring to is "don't use owning pointers". That is, don't use a pointer if you have to remember to delete the thing to which the pointer points. If there is no ownership involved (i.e. no responsibility for freeing memory), then there is nothing inherently bad about using pointers. In fact, pointers are often a more appropriate choice than references when "does not exist" is a valid possibility (just remember to check for null, which your logic would call for anyway).
Note: There are other "obsessions" that fall under "don't use pointers", but I don't see another that is relevant here. For the sake of an example: there is also "don't use a pointer when a reference will get the job done." This is good advice, but in this case a reference will not get the job done.

Answer 2

Nah. Doing it via parameters is silly. It's the year 2020 and you have std::optional and such.
I'd do it as follows. First, some helper code:
#include <type_traits>
#include <vector>
template <typename T> using const_qualified_value_type_impl =
std::conditional_t<std::is_const_v<T>,
typename std::add_const_t<typename T::value_type>,
typename T::value_type>;
template <typename T> using const_qualified_value_type =
const_qualified_value_type_impl<std::remove_reference_t<T>>;
static_assert(std::is_same_v<const_qualified_value_type<std::vector<int>>, int>, "");
static_assert(std::is_same_v<const_qualified_value_type<const std::vector<int>>, const int>, "");
#include <functional>
#include <optional>
template <typename T> class optional_ref
{
std::optional<std::reference_wrapper<T>> val;
public:
template <typename ...Args> constexpr optional_ref(Args &&...args) :
val(std::forward<Args>(args)...) {}
constexpr explicit operator bool() const { return static_cast<bool>(val); }
constexpr auto has_value() const { return val.has_value(); }
constexpr auto &value() const { return val.value().get(); }
constexpr auto &get() const { return val.value().get(); }
constexpr operator T&() const { return val.value().get(); }
};
Now we have an optional_ref type (a very rudimentary one, but still),
and we can use it when creating the get_first getter:
template <typename C>
auto get_first(C && container) -> optional_ref<const_qualified_value_type<C>>
{
auto const begin = container.begin();
static_assert(std::is_reference_v<decltype(*begin)>, "*begin() must return a reference");
if (begin == container.end()) return {};
return *begin;
}
Now a basic test:
#include <cassert>
int main()
{
std::vector<int> vect;
assert(!get_first(vect));
vect.push_back(0);
assert(get_first(vect));
assert(get_first(vect) == 0);
int &first = get_first(vect).value();
++first;
assert(get_first(vect) == 1);
const std::vector<int> cempty;
assert(!get_first(cempty));
const std::vector<int> cnon_empty{0};
assert(get_first(cnon_empty));
assert(get_first(cnon_empty) == 0);
auto &cfirst = get_first(cnon_empty).value();
static_assert(std::is_same_v<decltype(cfirst), const int &>, "");
}
That way:
get_first's return value is bool-convertible in boolean contexts, i.e. you can use it as if it were a bool to check if a reference is valid.
get_first's return value is convertible to a reference to the value stored in the container, and the value type is automatically const-qualified if the container is const-qualified. That typically is what you'd want, although don't take my word for it.
Ideally, optional_ref should be implemented using a pointer, but for demonstration purposes it was quicker to reuse std::optional and std::reference_wrapper.
But the above works (in a rudimentary fashion) under gcc, clang and msvc.
You'd use it as follows:
auto val = get_first(foo);
if (val.has_value())
{
auto &v = val.value();
// use v
}