Returning void from a double function? - c

Question

I have a function which is a double and normally returns the new value for a variable, but sometimes I don't want to change the variable and I would like to signal that by returning a special value, for example void. Is that possible?
For example:
double GetNewValue(int feature) {
switch( feature ) {
case TYPE1:
return void; // or maybe use return; here?
case TYPE2:
return 2.343;
default:
return featureDefaultValue;
}
}
PS: I know I can use NaN, but I already use it as a valid value with another meaning (not yet a number is available).
/EDIT: Thank you all for your answers, these 3 answers are all applicable to my problem and are all equally valid. I struggle right now in choosing which one I'm going to use (which will be the one I will accept, but I wish I could accept them all!).

Answer 1

In this case, you need to return two things from a function, not one. A common way to do so is taking a pointer to the return value, and returning a yes/no flag to indicate the validity of the actual double:
int GetNewValue(double *res, int feature) {
switch( feature ) {
case TYPE1:
return 0; // no change to res
case TYPE2:
*res = 2.343;
return 1;
default:
*res = featureDefaultValue;
return 1;
}
Now instead of doing this
double res = GetNewValue(myFeature);
the users of your function would need to do this:
double res;
if (GetNewValue(&res, myFeature)) {
// use res here - it's valid
} else {
// do not use res here - it's not been set
}

Answer 2

One way to do this is to pass the result variable as a pointer:
void AssignNewValue(int feature, double* result)
{
switch( feature ) {
case TYPE1:
return;
case TYPE2:
*result = 2.343;
break;
default:
*result = featureDefaultValue;
break;
}
}
Used like:
double featureValue = 42.0;
/* ... */
AssignNewValue(feature, &featureValue);

Answer 3

It sounds like you want an "optional" return parameter. You don't seem to (and rightly so) want to use 0.0 as the "no value" result because that means 0.0 can't be used for an actual value.
2 good solutions you sometimes see for this is to either use a "result code", or to use a pointer as the return result. (Pointers are more complicated). I'll start with #1 first:
1. Result codes
// definitions for result codes
#define FAIL 0
#define OK 1
int GetNewValue(int feature, double *result) {
switch( feature ) {
case TYPE1:
*result = 0.0 ;
return FAIL ; // caller of the function should recognize
// the call "failed"
case TYPE2:
*result = 200.0 ;
return OK ;
default:
*result = 47.0 ;
return OK;
}
}
// use:
double feature ;
int result = GetNewValue( 5, &feature ) ;
if( result == OK )
{
// do something with "feature"
}
2. Using pointers
double* GetNewValue(int feature) {
switch( feature ) {
case TYPE1:
return NULL ; // NO POINTER means FAIL
case TYPE2:
return new double(200) ;
default:
return new double( 47 ) ;
}
}
// use:
double* result = GetNewValue( 5 ) ;
if( result != NULL )
{
// result had a value, so you can use it
}
The gotcha with pointers is you need to remember to delete the result
delete result ; // when done with pointer that was created
// with `new`, you must `delete` it after
// otherwise you'll get a memory leak