C++ - tester un pointeur

Question

J'écris une méthode en retournant un double*. Cependant, je voudrais baser un autre comportement de méthode sur la sortie de cette méthode. Je voudrais avoir

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

Est-il approprié alors d'avoir methodReturningArray() retour soit le « initialisé » ou « construire » double* et si ce double* ne pouvait pas être convenablement être initialisés ou de construire, de retour comme ça

double* new_array ; 
return new_array ; 

? En d'autres termes, la sortie double* joue également le rôle d'un booléen pour vérifier si certaines propriétés sont terminées afin que la sortie double* puisse être générée.

Merci et salutations.

Answer 1

Pour indiquer que quelque chose que vous retournez par pointeur n'a pas été initialisé, utilisez return NULL. Et vérifiez avec if(double* d = method()) (ou de toute autre manière que vous aimez).

Cependant, ce n'est pas votre (ou mon) grand-père C++ et vous ne devriez écrire quelque chose comme ça, quand vous avez absolument raison de le faire. Je préférerais renvoyer un std::array ou std::vector par valeur enveloppée et lancer une exception si le comportement qui conduit à l'échec d'initialisation est en quelque sorte exceptionnel. Si l'échec de l'initialisation fait partie de l'idée, j'envelopperais la valeur de retour dans un boost::optional. Mais probablement j'écrirais quelque chose qui prend un OutputIterator pour ne pas forcer un conteneur particulier sur mon client. Notes sur le désastre: double* d; return d laissera votre client avec un pointeur qui pointe vers la mémoire aléatoire. Il n'y a aucun moyen pour elle de savoir si elle doit être deleted[] ou si elle est valide. Toujours initialiser vos pointeurs.

extraits de code:

// 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 { 

} 

Answer 2

Vous avez trois façons, fondamentalement.

1) En cas d'erreur, retournez la valeur NULL. Ensuite, vous pouvez faire des vérifications booléennes sans problème, et c'est suffisant dans la plupart des cas.

2) booléen de retour, et gérer la sortie double * en utilisant une référence ou un argument de pointeur comme ceci:

bool methodReturningArray(double **out) { *out = ...; return true; } 

double *out; 
if (!methodReturningArray(&out)) this_other_behavior(out); else .... 

3) Lancer une exception - l'OMI un peu alambiquée et unuseful.

Le renvoi d'un pointeur non initialisé ne vous permettra pas d'effectuer une évaluation booléenne sur celui-ci, et il est dangereux, car un tel pointeur sera supposé être un pointeur qui suit.