Returning an invalid reference - c++

Question

Sometimes when I'm programming in C++ I wish there was an undefined value for every variable something like Javascript!.
For example when I'm returning a value for out-of-bounds element of an array, it was useful to return an undefined instead of throwing an exception, or:
template <typename T, int SIZE>
class MyArray
{
T arr[SIZE];
static T badref;
public:
T &operator[](int i)
{
if (i >=0 && i < SIZE)
return arr[i];
else
throw std::string("OUT-OF-BOUNDS"); // or: return badref; !!
}
};
Another dirty(In my opinion) option is returning a reference of a pre-defind variable as a bad-reference variable. I know we can not assign null or something like that to a reference variable.
Is there an another well formed pattern to return a reference where caller has the ability to find out the returned value is not valid?
EDIT: I'm not mean a pointer

Answer 1

You can use boost::optional as #chris mentioned in his comment. It comes as a part of Boost libary. See this page for more details.
Modified MyArray class:
template <typename T, int SIZE>
class MyArray
{
T arr[SIZE];
public:
optional<T&> operator[](int i)
{
if (i >=0 && i < SIZE)
return optional<T&>(arr[i]);
else
return optional<T&>();
}
};
Usage:
MyArray<int>() array;
// fill array with data
optional<int&> result = array[0];
if (result) {
// item was found
} else {
// index out of bounds
}

Answer 2

I wish there was an undefined value for every variable something like Javascript!
You only have an "undefined" value for pointers (nullptr). A reference is (by definition) something pointing to a valid instance.
To return a reference to a static object, you should separate between const and non-const values of your operator:
template <typename T, int SIZE>
class MyArray
{
T arr[SIZE];
static T badref;
public:
T &operator[](int i)
{
if (i >=0 && i < SIZE)
return arr[i];
else
// returning ref here would allow clients to write:
// MyArray<int> a;
// a[-1] = 5; // valid if you return a non-const reference
throw std::string("OUT-OF-BOUNDS");
}
const T &operator[](int i) const
{
if (i >=0 && i < SIZE)
return arr[i];
else {
// MyArray<int> a;
// a[-1] = 5; // will not compile (cannot assign to const)
static const T invalid = T();
return invalid;
}
}
};

Answer 3

Whatever you think of, your solution needs to fit into the type system. So your function signature must explicitly say (this way or another) that the result may be T, but it may be something else too.
Common ways for that are:
Instead of returning a value, return a status code and output the value via an "out" parameter (a pointer or reference):
bool tryGet(int i, T& result);
Return a tuple (status, value) like:
std::tuple<bool, T> get(int i)
(If couldn't get, consider the second tuple element irrelevant - requires T to have a default constructor)
Use boost::variant (flexible, but requires boost)
Use boost::optional (simpler version of the above, when you only need "either T or nothing")

Answer 4

The main goal of references is to avoid invalid (NULL) values while allowing functions to modify their arguments and keep from copying data. If you need a NULL value, use a pointer.