當返回類型是向量容器時，是否有在 c++ 中返回 Null 的解決方法？

Question

問題是我正在實現一個遞歸，其中我必須使用NULL值來指定被遍歷的遞歸分支是無效的。

但是在 C++ 中，當返回類型為容器（在我的情況下為矢量容器）時，我們無法返回NULL 。

那么這個問題有什么解決方法還是我必須使用其他邏輯？

代碼：

#include<iostream>
#include<vector>


std::vector<int> howSum(int target,std::vector<int> in){
    if(target < 0 ) return {-1}; 
    if(target == 0) return {};

    for(int num : in){
        int remainder = target - num ;
        std::vector<int> remResult = howSum(remainder,in);
        if(remResult[0] != -1 || remResult.empty()){
            remResult.push_back(num);
            return remResult;
        }
    }

    return {-1};
}

int main(){

    std::vector<int> v = {2,4,3};
    int targetSum = 8;

    std::vector<int> r = howSum(targetSum,v);

    for(int o : r)
        std::cout<<o<<" ";

    return 0;
}

編輯：

我非常感謝所有建議和解決方案，但我想要的是一個原始解決方案，它沒有使用更新的 c++ 編譯（即 c++17 和 c++20）。 另外，如果可能的話，請查看我實施的原始解決方案，如果可以改進，請提出一些建議。

我自己發現的另一種解決方案（原始解決方案）

我正在為訪問此問題的人們寫這篇文章以供參考。

解決方案：

#include<iostream>
#include<vector>
#include<string>

std::string howSum(int target,std::vector<int> v){

    if(target == 0)    return "";
    if(target < 0)     return "null";
    
    for(int num : v){
        int rem = target - num;
        std::string remRes = howSum(rem,v);
        if(remRes != "null"){
            remRes += std::to_string(num);
            remRes += " ";
            return remRes;
        }
        
    }
    return "null";
}

int main()
{
    std::vector<int> v = {2,3,4};
    int targetSum = 8;
    
    std::cout<<howSum(targetSum,v);
    return 0;
} 

我的動態問題解決方案

#include<iostream>
#include<vector>
#include<string>
#include<unordered_map>

std::unordered_map<int,std::string> mem;

std::string howSum(int target, std::vector<int> v){
    if(mem.find(target) != mem.end())
        return mem[target];
    if(target == 0)    return "";
    if(target < 0)     return "null";
    
    for(int num : v){
        int rem = target - num;
        std::string remRes = howSum(rem,v);
        if(remRes != "null"){
            remRes += std::to_string(num);
            remRes += " ";
            mem[target] = remRes;
            return mem[target];
        }
        
    }
    mem[target] = "null";
    return mem[target];
}

int main()
{
    std::vector<int> v = {7,14};
    int targetSum = 300;
    
    std::cout<<howSum(targetSum,v);
    return 0;
}

Answer 1

您有以下選擇：

返回結果+布爾

返回std::pair<std::vector<int>, bool> ，甚至更好的是這樣的結構

struct Result {
    std::vector<int> result;
    bool is_valid;
};

Result howSum(int target, const std::vector<int>& in);

其中bool將指示結果向量是否實際可用。

Output參數

返回一個bool ，指示操作是否成功並使用 output 參數（請注意，非 const 引用用於 output 參數，以便它可以在 ZC1C425268E68385D1AB5074C17A 內部進行修飾，然后在其外部使用）

bool howSum(int target, const std::vector<int>& in, std::vector<int>& result);

optional

使用帶有 C++17 的std::optional或來自boost庫的類似boost::optional ：

std::optional<std::vector<int>> howSum(int target, const std::vector<int>& in);

將std::optional轉換為bool或使用has_value方法檢查您是否返回了實際結果。

請注意，在每種情況下，最好通過const &傳遞輸入向量以避免不必要的復制。

Answer 2

使用可選（c ++ 17），你可以做這樣的事情

#include<iostream>
#include<vector>
#include<optional>


std::optional<std::vector<int>> howSum(int target,std::vector<int> in){
    if(target <= 0 ) return {}; // returns "empty" optional

    auto num = in.back();
    in.pop_back();
    int remainder = target - num ;
    auto maybe_r = howSum(remainder, in);
    if (!maybe_r.has_value())
        return howSum(target, in);
    else {
        auto r = maybe_r.value();
        r.push_back(num);
        return r;
    }
}

int main(){

    std::vector<int> v = {2,4,3,1};
    int targetSum = 8;

    auto maybe_r = howSum(targetSum,v);

    if (!maybe_r.has_value()) {
        std::cout << "no result\n";
    } else {

        auto r = maybe_r.value();
        for(int o : r)
            std::cout<<o<<" ";

    }
    return 0;
}