C++对和指针

Question

我不知道我能做些什么来使这个工作在C++中。

的打算是：

pair<int, int> foo() { 
    if(cond) { 
    return std::make_pair(1,2); 
    } 
    return NULL; //error: no viable conversion from 'long' to 'pair<int, int> 
} 
void boo() { 
    pair<int, int> p = foo(); 
    if (p == NULL) { //error: comparison between NULL and non-pointer ('int, int' and NULL) 
    // doA 
    } else { 
    int a = p.first; 
    int b = p.second; 
    // doB 
    } 
} 

既然不能在C++中使用返回NULL，这里是我的第二次尝试：

pair<int, int>* foo() { 
    if(cond) { 
    return &std::make_pair(1,2); //error: returning address of local temporary object) 
    } 
    return nullptr; 
} 
void boo() { 
    pair<int, int>* p = foo(); 
    if (p == nullptr) { 
    // doA 
    } else { 
    int a = p->first; 
    int b = p->second; 
    // doB 
    } 
} 

什么是正确的方法能够返回一个对和一个空值。

Answer 1

尝试通过引用传递一对foo（），然后从该函数返回一个指示成功或失败的布尔值。像这样：

bool foo(pair<int, int>& myPair) { 
    if(cond) { 
    myPair = std::make_pair(1,2); 
    return true; 
    } 
    return false; 
} 
void boo() { 
    pair<int, int> myPair; 
    if (!foo(myPair)) { 
    // doA 
    } else { 
    int a = myPair.first; 
    int b = myPair.second; 
    // doB 
    } 
} 

编辑：根据你在做什么，你应该杀了foo()如果可能的话，评估cond内boo()

void boo() { 
    pair<int, int> myPair; 
    if (!cond) { 
    // doA 
    } else { 
    myPair = std::make_pair(1,2); 
    int a = myPair.first; 
    int b = myPair.second; 
    // doB 
    } 
} 

Answer 2

你应该使用一个例外：

std::pair<int, int> foo() { 
    if(cond) { 
     return std::make_pair(1,2); 
    } 
    throw std::logic_error("insert error here"); 
} 

和你的boo功能：

try { 
    std::pair<int, int> p = foo(); 
    int a = p.first; 
    int b = p.second; 
} catch (std::logic_error const& e) { 
    // do something 
} 

而here就是现场的例子。

---

在可选的可以使用std::optional（因为C++ 14）或boost::optional：与升压版本

std::optional<std::pair<int, int>> foo() { 
    if(cond) { 
     return std::make_pair(1,2); 
    } 
    return {}; 
} 

std::optional<std::pair<int, int>> p = foo(); 
if (p) { 
    int a = p->first; 
    int b = p->second; 
} else { 
    // do something 
} 

而且here的一个工作实例。

Answer 3

也许你正在寻找一个Nullable类型。没有理由使用动态内存。这种方法完全是夸张的，不必要的，但它最符合你试图用你的原始代码实现的东西。

#include <iostream> 
#include <map> 

template <typename T, typename U> 
struct NullablePair 
{ 
    std::pair<T, U> pair; 
    T first = pair.first; 
    U second = pair.second; 
    NullablePair(const std::pair<T, U>& other) : pair(other) { } 
    NullablePair() { } 
    operator std::nullptr_t() const { 
     return nullptr; 
    } 
}; 

template <typename T, typename U> 
NullablePair<T, U> foo(bool cond) { 
    if(cond) { 
    return NullablePair<T, U>(std::make_pair(1,2)); 
    } 
    return NullablePair<T, U>(); 
} 

void boo() { 
    NullablePair<int, int> p = foo<int, int>(false); 
    if (p == nullptr) { 
    std::cout << "Nullptr.\n"; 
    } else { 
    int a = p.first; 
    int b = p.second; 
    } 
} 

int main() 
{ 
    boo(); 
} 

Answer 4

如果你想保持函数签名，那么你可以使用pair。因此，在函数foo（）的return语句中，可以返回std :: make_pair（NULL，NULL）。

pair<int, int> foo() 
{ 
    // Initialize cond 

    if(cond) 
     return std::make_pair(1,2); 
    return std::make_pair(NULL, NULL); 
} 

然后可以检查是否p.first和p.second等于NULL在BOO（）函数