How to return NULL from a method in a Template Class

Question

I have a method which looks like this:

template <typename T>
T Test<T>::FindItem(T item)
{
    if(found)
        //return original value, no problem here
    else
        //I want to return NULL here, like:
        return NULL; 
}

This fails in certain cases at runtime because some of the values can't be converted to NULL in C++ e.g., std::string. What approach should I follow here?

Answer 1

Most types are default constructable you have have a traits template class that can be specialized (with the default returning a default initialized object).

template <class T>
struct Make {
    static T Default()
    {
         return T();
    }
};


class not_default_constructable {
public:
    explicit not_default_constructable(int i) {}
};

// specialize for not_default_constructable     
template <>
struct Make <not_default_constructable> {
    static not_default_constructable Default()
    {
         return not_default_constructable(42);
    }
};

Answer 2

Here, Stroustrup gives a couple of arguments for avoiding NULL in C++:

• The definition is just 0, so there's no actual gain [and more to type]
• It's a macro, and macros are best avoided in C++

The suggestion, again from that page is:

• Use a plain 0, or (for C++0xwhatever) nullptr.

Second, if you want to return an invalid pointer as a signal of failure, you need to declare the function as returning a pointer to a type, not the type itself.

Third, most standard library find() functions return iterators, rather than elements directly. That gives you the possibility to implement the "nothing found" case differently.

Answer 3

If you want to return by value and don't want to mess with returning pointers and new/delete, you can just do like this:

template <typename T>
boost::optional<T> Test<T>::FindItem(T item)
{
    if(found)
        //return original value
    else
        return boost::none; 
}

and use it this way:

Test<int> var;
boost::optional<int> V = var.FindItem(5)

if (V)
{
    // found
    int val = *V;
}
else
{
    // not found
}

Answer 4

You should return T* non T

Answer 5

Maybe I'm being too simplistic, but I prefer simply returning a bool:

template <typename T>
bool Test<T>::FindItem(T item)
{
    if (!found)
        return false;    
    item = <found item>;        
    return true; 
}

Answer 6

You have a function that might return a valid object, but also an indication that no valid object exists. Combined with a situation where all the possible object values are valid, this is a design problem with your find function. (Even if you tweaked the function so that it would, for example, return an empty string if it doesn't find one, how would this be distinguishable from successfully finding an empty string?)

Over time, several ways out of this dilemma were found. So you could return a pointer/iterator instead of returning the actual value. Then a NULL pointer/invalid iterator would indicate "not found". Or you could take a value by non-const reference, assign the result to it and indicate success/failure by a returned boolean. Or take one of the other solutions posted here. But all will require that you change the function's interface -- because as it is it has a design error.

Anyway, before you jump in and do this, you should ask yourself why you write your own container/algorithm instead of using one from the std lib.

Answer 7

Return T(). If T is of type sometype *, it will be initialized to a null pointer. If T is of type sometype, it will return an object created with the default constructor, which should suffice (std::string will be empty, integral types like ints will be 0, etc).

Answer 8

In my opinion, you are trying to complicate yourself a bit by trying to return a NULL value...

Instead do something similar to this:

class SomeError
{};
template <typename T>
    T Test<T>::FindItem(T item)
    {
     if(found) 
      //return original value, no problem here
     else
      throw(SomeError);
    }

Throwing an empty class does not cost anything...

Answer 9

You could throw an exception when it is not found.

Since you have no knowledge of the type being looked-up and returned, you can not designate any particular value of that type as an error code. In essence, you are trying to squeeze the full domain of a type plus an error value into the domain of the type.

The suggestions to use iterators or other wrappers help solve the problem by extending the domain of the return type to encompass error values, but if you want to stick to the actual types you are dealing with, exceptions are you best other choice. That's what they're for.