C++ Python'；s在C++；

我喜欢Python中的特性，当它没有找到正确的返回值时，它可以不返回任何值。例如：

def get(self, key):
    if key in self.db:
        return self.db[key]
    return None

<>我需要在C++中实现相同的特性。我考虑了一些可能性

返回true/false，如果为true，则从引用或指针获取值 抛出一个错误以通知None case

int get（字符串键）throw（int）
{
如果（输入（键，db））{
结果=db[键]；
返回结果；
}
掷0；
}
试一试{
....
}
捕获（整数n）
{
CUT< P>我认为C++中的不同项目使用不同的标准，但是<>强>返回true /false 是C++中最常用的方法，虽然有些人喜欢在成功时返回false，而其他人则希望在成功时返回true。在其他情况下，如果希望得到的值是指针，则返回null是另一个。C++中常用的方法.< /P>
例如，如果您正在处理与Microsoft相关的项目，则最常见的方法是返回，这是Microsoft引入的返回类型

在linux中，函数通常在成功时返回0，非零值表示错误代码。
（
> p>），正常的C++方式（C++：不是Python）是从这些函数中返回迭代器，当找不到项时返回<代码>（）/<代码>。
但是，如果希望使用非迭代器返回值，请在返回Python的
none
时使用
boost:：optional
并返回
boost:：none

绝对不要使用<代码>投掷< /> >除非你在正常执行过程中不会有错误的情况。
 < P>我会说这三种方法在C++中都很常见。
不用说，如果返回类型已经可以有某种“无效”或“僵尸”状态（例如，像
NULL
指针或
NaN
数字），那么这可能是最容易使用的

“通过引用获取输出参数并返回错误代码”是更传统的C风格的处理方式，这当然是非常常见的。传统是在成功时返回0，在失败时返回一些错误代码（任何非零值）

如果在代码中采用异常，“如果无法返回值，则抛出异常”通常是有意义的。这是非常常见的，但不是普遍接受的（不是每个人都喜欢或出于相同目的使用异常）

前两个选项是永无休止的宿怨（即错误代码与例外），这实际上取决于你选择哪一方。因此，我想让你参考这场辩论（当然，这对StackOverflow来说太主观了）

我想说，“返回一对
bool
和值”不太常见，但我已经见过很多次了。通过采用元组（
boost:：tuple
或
std:：tuple
（C++11））和使用层（
boost:：tie
或
std:：tie
（C++11）），从一个函数返回多个值的整个想法（就像许多语言所允许的那样）变得越来越有吸引力，并在实践中得到了应用

在其他选项中，您有
boost:：optional
，其名称不言自明（基本上，第三个选项（一对）包装在一个更漂亮的包中）。您还可以使用Alexandrescu的预期模板，它提供了所有三个选项的混合，这样您可以获得一个与标志捆绑在一起的返回值，以了解它是否有效，并与一个异常捆绑在一起，该异常描述它无法生成值的原因，如果您尝试读取无效值，该异常将自动抛出。Howev呃，模板需要C++11功能才能工作。
我使用一个小的自定义
选中的
模板类实现了好/坏返回值。
我的实际类更全面一些，包括赋值运算符、错误原因字符串和引用类型的专门化等等，这就是为什么我没有使用
boost:：optional
。如果有兴趣，我可以发布完整的类

本课程的主要内容如下：

static const class Bad {} None;

template<typename ValueType>
class Checked
{
public:
    // Constructor for good value.
    Checked(ValueType x)
        : value(x), valid(true)
    {}

    // Constructor for bad value.
    Checked(Bad)
        : value(), valid(false)
    {}

    operator ValueType(void) const
    {
        if (!valid)
            ;//assert or throw...

        return value;
    }

    ValueType value;
    bool valid;
};

静态常量类坏{}无；
模板
类检查
{
公众：
//构造器的良好价值。
选中（值类型x）
：值（x），有效（真）
{}
//错误值的构造函数。
选中（坏）
：value（），有效（false）
{}
运算符ValueType（void）常量
{
如果（！有效）
；//断言或抛出。。。
返回值；
}
值类型值；
布尔有效；
};

可以这样使用：

Checked<int> Divide(int numerator, int denominator)
{
    if (denominator == 0)
        return Bad(); // or None;

    return numerator / denominator; // Automatically uses the "good value" constructor
}

选中除法（整数分子、整数分母）
{
如果（分母==0）
返回Bad（）；//或无；
返回分子/分母；//自动使用“good value”构造函数
}

或：

检查结果=除以（4,5）；
if（result.valid）
std:：cout在返回指针时，我可以使用reinterpret_cast返回NULL

class A
{
};

A* a(int i)
{
    if (i == 0) return new A();
    return reinterpret_cast<A*>(NULL);
}
int main(int argc, char *argv[]) {
    A* result = a(1); // result is NULL
    if (result == NULL) {
        cout << "NULL returned";
    }
    result = a(0);
    if (result != NULL) {
        cout << "NON NULL returned";
    }
}

A类
{
};
A*A（int i）
{
如果（i==0）返回新的A（）；
返回reinterpret_cast（NULL）；
}
int main（int argc，char*argv[]）{
A*result=A（1）；//结果为空
如果（结果==NULL）{
在C++14中，如果逻辑合适，不能使用
boost:：optional
并切换到
std:：optional
。我想说它与Python代码最为相似，但不同的语言会产生不同的习惯用法。然而，如果在正常执行过程中不应该出现这种情况，请使用
throw
@MooingDuck一些像我这样的ppl不喜欢使用它例外。我希望有人发现有趣的。C++标准有点类似于<代码>配对< /Cord>返回类型方法。看1-2）。但是他们做的可能是因为通过代码< > Iterator < /C> >不合适。如果不能使用迭代器，我猜<代码>配对< /C>可能是有用的。（例如，返回一些默认元素）。@luk32:这不完全相同，因为
map:：insert
返回的两个元素都是有效的。这不是失败的信号
static const class Bad {} None;

template<typename ValueType>
class Checked
{
public:
    // Constructor for good value.
    Checked(ValueType x)
        : value(x), valid(true)
    {}

    // Constructor for bad value.
    Checked(Bad)
        : value(), valid(false)
    {}

    operator ValueType(void) const
    {
        if (!valid)
            ;//assert or throw...

        return value;
    }

    ValueType value;
    bool valid;
};

Checked<int> Divide(int numerator, int denominator)
{
    if (denominator == 0)
        return Bad(); // or None;

    return numerator / denominator; // Automatically uses the "good value" constructor
}

Checked<int> result = Divide(4, 5);
if (result.valid)
    std::cout << result; // or result.value
else
    std::cout << "Bad!";

class A
{
};

A* a(int i)
{
    if (i == 0) return new A();
    return reinterpret_cast<A*>(NULL);
}
int main(int argc, char *argv[]) {
    A* result = a(1); // result is NULL
    if (result == NULL) {
        cout << "NULL returned";
    }
    result = a(0);
    if (result != NULL) {
        cout << "NON NULL returned";
    }
}