Question

I am writting a method returning a double*. However, I would like to base another method behavior on output from this method. I would like to have

if (methodReturningArray()==0)
{
    this_behavior();
}
else
{
    this_other_behavior(methodReturningArray());
}

Is it appropriate then to have methodReturningArray() returning either the ‘initialized’ or ‘build’ double* and if this double* could not be appropriately be initialized or build, returning like that

double* new_array ;
return new_array ;

?

In other words, the double* output plays also role of a boolean to check whether some property is completed so that the double* output can be built.

Thanks and regards.

Answer 1

To indicate that something that you return by pointer has not been initialized, use return NULL. And check for it with if(double* d = method()) (or in any other fashion you like).

However, this is not your (or my) grandfathers C++ and you should only write something like this, when you absolutely have reason to do so. I would prefer to return either a std::array or std::vector by value wrapped and throw an exception if the behavior that leads to initialization failure is somehow exceptional. If failing to initialize is part of the idea I’d wrap the return value in a boost::optional. But probably I’d write something that takes an OutputIterator to not force any particular container on my client.

Notes on disaster: double* d; return d will leave your client with a pointer that points to random memory. There is no way for her to figure out if has to be deleted[] or if it is valid. Always initialize your pointers.

Code snippets:

// outputiterator
template<typename OutputIterator>
void myFunc(OutputIterator o) {
  // fill stuff in
  if(someThing) {
    for(int i = 0; i < 5; ++i)
    {
      *o++ = 23;
    }
  } else {
    // leave it empty
  }
}

// client calls like:
std::vector<double> v;
myFunc(std::back_inserter(v));
if(!v.empty()) {

} else {

}

// exception
std::vector<double> myFunc() {
  std::vector<double> v;
  if(someThing) { v.push_back(23); return v; }
  else throw std::runtime_error("Nargh!");
}

// client
try {
  auto v = myFunc();
} catch(std::runtime_error err) {

}

// optional
boost::optional<std::vector<double>>
myFunc() {
  std::vector<double> v;
  if(someThing) { v.push_back(23); return v; }
  else return boost::optional< std::vector<double> >();
}

//client 
auto v = myFunc();
if(v) {

} else {

}