Wie kann man sagen, dass es kein Ergebnis einer Funktion mit Rückgabewert gibt?

Question

Ich habe eine kurze Frage. Bei einer Funktion, die ein Objekt einer Klasse als Ergebnis zurückgibt, was soll ich zurückgeben, wenn es kein Ergebnis gibt (sagen wir, weil ein Index außerhalb des Bereichs liegt)? Ich könnte ein neues "leeres" Objekt zurückgeben, aber wie kann ich darauf hinweisen, dass es keine erfolgreiche Berechnung gab?

Ich vermute, es gibt einen gemeinsamen Ansatz.

Answer 1

Sie können eine Ausnahme auslösen, wenn die Werte nicht den erwarteten Ergebnissen entsprechen.

Ein Tutorial kann mit einem try und catch Prinzip Eine Ausnahme arbeitet bei http://www.cplusplus.com/doc/tutorial/exceptions

finden.

Ein Programm "versucht" Code auszuführen. Wenn etwas Unerwartetes passiert, "wirft" der ausgeführte Code ein Objekt, eine Variable oder was auch immer, und dies wird abgefangen. In der catch-Anweisung können Sie Code eingeben, was passieren soll, wenn das Unerwartete passiert ist.

Folgen Sie einfach dem Tutorial.

Answer 2

Der übliche Ansatz in C++ ist entweder eine Ausnahme zu werfen oder einen Wrapper wie boost::optional zu verwenden.

Eine Ausnahme sollte ausgelöst werden, wenn es sich um eine Art von Fehler handelt, der boost::optional -Verbund ist geeigneter, wenn es ein gültiger Anwendungsfall Ihrer Funktion ist, ein leeres Ergebnis zurückzugeben. Ein Beispiel, das mir in den Sinn kommt, ist SQL's NULL. boost::optional erwies sich als ziemlich praktisch in unserer Codebasis.

Answer 3

Nach der Philosophie der vector::at Methode gehen out_of_range Ausnahme wenn möglich.

Answer 4

Es hängt davon ab, was die Semantik der Operation ist.

Wenn ein Fehler aufgetreten ist, sollten Sie auf jeden Fall eine Ausnahme werfen:

#include <stdexcept> // Necessary for standard exceptions 

X foo() 
{ 
    ... 
    if (/* something goes wrong... */) 
    { 
     // There may be a more appropriate exception class. You could 
     // also derive your own exception class from std::exception... 
     throw std::logic_error("Whatever!"); 
    } 

    ... 
} 

... 

try 
{ 
    X x = foo(); 
    // Work with x... 
} 
catch (std::logic_error const& e) // Catch what is appropriate... 
{ 
    std::cout << e.what(); 
} 

Wenn ein nicht-Wert zurückgegeben wird keine Fehlerbedingung nicht bezeichnen, könnten Sie Boost.Optional verwenden. Alternativ, vorausgesetzt, Sie können ein „leeres“ Objekt des Typs erstellen X, Sie ein Paar Rückkehr dessen zweites Element denken könnte, ist ein bool Flag, das das erste Element gibt an, ob ein gültiges Objekt ist oder nicht, wie unten:

std::pair<X, bool> foo(); 

... 

bool valid; 
X x; 
std::tie(x, valid) = foo(); 
if (valid) 
{ 
    // Use x... 
} 

Answer 5

Wenn wir über eine fehlerhafte Situation sprechen, ist das Auslösen einer Ausnahme die richtige Lösung.

#include<exception> 

Object * GenerateObject(int i) 
{ 
    if (i < 0) 
     throw std::out_of_range("i"); 

    return new Object(i); 
} 

int main(int argc, char * argv[]) 
{ 
    try 
    { 
     Object * obj = GenerateObject(-1); 

     // Succeeded 
     return 0; 
    } 
    catch (std::exception & e) 
    { 
     // Failed, exiting with error value 
     return 1; 
    } 
} 

Wenn ein leerer Wert zulässig ist, können Sie einen bestimmten Wert für diese Klasse angeben, z.

class Rectangle 
{ 
private: 
    int left, top, width, height; 

public: 
    Rectangle(l, t, w, h) 
    { 
     left = l; 
     top = t; 
     width = w; 
     height = h; 
    } 

    public static Rectangle empty; 
} 

Rectangle Rectangle::empty = Rectangle(0, 0, -1, -1); 

// ... 

Rectangle DoSth(int i) 
{ 
    // i < 0 is NOT considered an error here 
    if (i < 0) 
      return Rectangle::empty; 

    // Further processing 
} 

Answer 6

Sie können eine Enumeration mit dem zurückgegebenen Objekttyp paaren. Wenn die zurückgegebene Enumeration ein bestimmter Wert ist, ist das Objekt gültig, andernfalls befindet sich das Objekt in einem ungültigen Zustand.

// This is a working C++11 example. 
#include <utility> 
#include <memory> 

enum result 
{ 
    ok, 
    out_of_range, 
    some_other_error 
}; 

class object 
{ 
    public: 
     object() {} 
}; 

typedef std::shared_ptr<object> object_ptr; 

typedef std::pair< result, object_ptr > return_type; 

return_type some_function(int index) 
{ 
    if (index > 5) 
    { 
     return return_type{ result::out_of_range, nullptr }; 
    } 

    return return_type{ result::ok, object_ptr{ new object() } }; 
} 

int main() 
{ 
    return_type res = some_function(10); 
    if (res.first == result::ok) 
    { 
     // Do something with res.second 
    } 
    else 
    { 
     // Handle the error 
    } 
} 

Ich würde wahrscheinlich nur eine Ausnahme stattdessen werfen.