C++ C++；在早期阶段中断一项功能

我有两个问题

第一个是关于使用函数。我需要在一个条件下，在早期阶段中断一个函数

例如：

std::string concat(std::string& x, std::string& y, std::vector<std::string>& vec)
{
    if (atoi(x.c_str()) < 0)
    {
        return;
    }
    else {
        std::string concatStr = y + x;

        top_back(vec);
        top_back(vec);

        return concatStr;
    }
}

std:：string concat（std:：string&x，std:：string&y，std:：vector&vec）
{
if（atoi（x.c_str（））<0）
{
返回；
}
否则{
std:：string concatStr=y+x；
上背部（vec）；
上背部（vec）；
返回concatStr；
}
}

如您所见，函数必须返回一个字符串，但是如果字符串x（我当然会转换为int）小于0，那么理论上我应该中断函数

写

返回的问题是编译器告诉我它需要返回一个值

第二个问题是如何从控制台中删除最后一行？
这与第一个问题有关，因为有人建议
return”“
是一个很好的解决方法，但它会在控制台中写入一个空格，这在我编写的程序中是不好的，会导致问题。
如果可以使用C++17进行编译，则可以使用它允许您有选择地从函数返回某些内容。我们会将您的函数重写为

std::optional<std::string> concat(std::string& x, std::string& y, std::vector<std::string>& vec)
{
    if (atoi(x.c_str()) < 0)
    {
        return {};
    }
    else 
    {
        std::string concatStr = y + x;

        top_back(vec);
        top_back(vec);

        return concatStr;
    }
}

但通话地点将保持不变


最后，如果一个空字符串永远不会是函数的有效返回，您可以返回该字符串并在调用站点中处理它，如

std::string concat(std::string& x, std::string& y, std::vector<std::string>& vec)
{
    if (atoi(x.c_str()) < 0)
    {
        return {};
    }
    else 
    {
        std::string concatStr = y + x;

        top_back(vec);
        top_back(vec);

        return concatStr;
    }
}


int main()
{
    //...
    auto ret =  concat(some, stuff, here)
    if(ret != "") // only print if ret actually holds a string
        std::cout << ret;
    //...
}

std:：string concat（std:：string&x，std:：string&y，std:：vector&vec）
{
if（atoi（x.c_str（））<0）
{
返回{}；
}
其他的
{
std:：string concatStr=y+x；
上背部（vec）；
上背部（vec）；
返回concatStr；
}
}
int main（）
{
//...
auto ret=concat（一些，东西，这里）
if（ret！=“”）//仅当ret实际包含字符串时才打印
std:：cout因为您对C++17解决方案不满意，所以可以编写自己的
std:：optional
实现

template<typename T>
class Optional
{
    bool m_HasValue;
    T m_Object;
public:
    Optional() : m_HasValue(false){};
    Optional(T&& Object) : m_HasValue(true), m_Object(std::forward<T>(Object)){};
    operator T&(){return m_Object;}
    operator bool(){return m_HasValue;}
    T& operator*(){return m_Object;}
};

你必须使用C++11吗？如果你可以使用C++17，你可以使用为这个用例设计的
std:：optional
。如果你必须坚持使用C++11，你可以使用
boost:：optional
。不，我不必。我如何实现std:：optional？现在我注意到，即使我的编译器支持C++17，它也一直在告诉我这一点对于std:：optional的使用，我需要c++17。您启用了吗？如果您使用的是gcc或clang，您需要使用
-std=c++17
@NathanOliver来编译，
std:：optional
？
return”“；
很好，或者更好
return{}
如果您的编译器支持这一点。您可能会像
std：：cout那样输出字符串。C++11标准替代方案是什么？@IvanStoianov在
可选
之前的一个替代方案是返回指针，并使用动态内存。
std：：unique_ptr
使这非常简单和安全。这也可能是一个不错的选择如果负数不常见，可以称为异常，
抛出异常的案例。可能也值得替代
atoi
。现在没有检查
atoi
失败。非常感谢。另外，为了记录，您如何从控制台（不是在容器或数组中）删除最后一行？如果您不能使用c++17，那么还有boost:：optional（std:：optional就是从中获取的）。
std::string concat(std::string& x, std::string& y, std::vector<std::string>& vec)
{
    if (atoi(x.c_str()) < 0)
    {
        return {};
    }
    else 
    {
        std::string concatStr = y + x;

        top_back(vec);
        top_back(vec);

        return concatStr;
    }
}


int main()
{
    //...
    auto ret =  concat(some, stuff, here)
    if(ret != "") // only print if ret actually holds a string
        std::cout << ret;
    //...
}

template<typename T>
class Optional
{
    bool m_HasValue;
    T m_Object;
public:
    Optional() : m_HasValue(false){};
    Optional(T&& Object) : m_HasValue(true), m_Object(std::forward<T>(Object)){};
    operator T&(){return m_Object;}
    operator bool(){return m_HasValue;}
    T& operator*(){return m_Object;}
};

using std::string;
Optional<string> DoSomething(string Input)
{
    if(Input == "dontprocessme")
        return {}
    // ... otherwise process the string
    string Output;
    // blah blah
    return Output;
}

// ...
auto RetString = DoSomething("processme");
if(RetString)
    std::cout << *RetString;