C++ pairs and pointers - c++

Question

I don't know what can I do to make this work in C++.
The intend is:
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
}
}
Since I cannot use return NULL in C++, here is my 2nd try:
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
}
}
What is the correct way to be able to return a pair and a null value.

Answer 1

You should use an exception:
std::pair<int, int> foo() {
if(cond) {
return std::make_pair(1,2);
}
throw std::logic_error("insert error here");
}
and in your boo function:
try {
std::pair<int, int> p = foo();
int a = p.first;
int b = p.second;
} catch (std::logic_error const& e) {
// do something
}
And here's the live example.
In alternative you can use std::optional (since C++14) or 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
}
And here's a the working example with the boost version.

Answer 2

Try passing in a pair to foo() by reference, then returning a bool from that function indicating success or failure. Like so:
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
}
}
Edit: Depending on what you're doing, you should just kill foo() if possible and evaluate cond within 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 3

Perhaps you're looking for a Nullable type. There's no reason to use dynamic memory. This approach is completely bombastic and unnecessary, but it most fits what you were trying to 'achieve' with your original code.
#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

If you want to maintain the function signature, then you can use pair. So in your return statement in the function foo(), you can 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);
}
You can then check if p.first and p.second equal NULL in boo() function