C++ 语法问题 : if var ! = type int

Question

我正在尝试编写一个 if 语句，但找不到要使用的正确表达式形式。我正在考虑写这样的东西:

if ( var != type(int) )

但是，我不确定具体该怎么做，而且这种方法行不通。

至少我的思路是正确的吗？

Answer 1

听起来您正在尝试重载函数:

void foo(int i)
{
    // stuff
}

void foo(float f)
{
    // stuff
}

int main(void)
{
    int i = 10;
    float f = 1.0f;

    foo(i); // calls foo(int)
    foo(f); // calls foo(float)
}

如果你想要 int - 特殊行为，然后在所有其他情况下想要其他东西，你可以使用模板:

template <typename T>
void foo(T t)
{
    // T is something
}

template <>
void foo(int i)
{
    // for int's only
}

int main(void)
{
    int i = 10;
    float f = 1.0f;
    double d = 2.0;

    foo(i); // calls specialized foo
    foo(f); // calls generic foo
    foo(d); // calls generic foo
}

---

根据您的评论 (“手头的任务是一个简单的程序:取两个用户输入的整数并将它们相加。将输入限制为仅整数。我可以在 Python 中完成，我也在按照这些思路进行思考。 if num1 != type(int): print "You did not enter an integer, please enter a integer."else: continue"), 你想要这样的东西:

#include <iostream>

int main(void)
{
    int i;
    std::cin >> i;

    if (std::cin.fail())
    {
        std::cout << "Not valid!" << std::endl;
    }
    else
    {
        // ...
    }
}

这将通知诸如“@#$”、“r13”之类的无效输入，但不会捕获诸如“34fg”、“12$#%”之类的情况，因为它将读取int，并分别在“fg”和“$#%”处停止。

要检查这一点，您必须读入一行输入，然后尝试将该行转换为您想要的类型。 (谢谢，litb)。这意味着您的问题更多 like this question :

#include <iostream>
#include <sstream>
#include <string>

int main(void)
{
    std::string input;
    std::getline(std::cin, input);

    std::stringstream ss(input);
    int i;
    ss >> i;

    if (ss.fail() || !(ss >> std::ws).eof())
    {
        std::cout << "Not valid!" << std::endl;
    }
    else
    {
        // ...
    }
}

这会执行以下操作:获取输入，并将其放入 stringstream。然后在解析 int 之后，流出任何剩余的空白。之后，如果 eof 为 false，则表示有剩余字符；输入无效。

包裹在函数中使用起来更容易。在另一个问题中，类型转换被重构了；在这个问题中，我们使用了强制转换，但将输入与它一起包装起来。

#include <iostream>
#include <sstream>
#include <string>

bool parse_int(int& i)
{
    std::string input;
    std::getline(std::cin, input);

    std::stringstream ss(input);
    ss >> i;

    return !(ss.fail() || !(ss >> std::ws).eof());
}

int main(void)
{
    int i;

    if (!parse_int(i))
    {
        std::cout << "Not valid!" << std::endl;
    }
    else
    {
        // ...
    }
}

或者更笼统地说:

#include <iostream>
#include <sstream>
#include <string>

template <typename T>
bool parse_type(T& t)
{
    std::string input;
    std::getline(std::cin, input);

    std::stringstream ss(input);
    ss >> t;

    return !(ss.fail() || !(ss >> std::ws).eof());
}

int main(void)
{
    int i;

    if (!parse_type(i))
    {
        std::cout << "Not valid!" << std::endl;
    }
    else
    {
        // ...
    }
}

这让您可以通过错误检查来解析其他类型。

---

如果您对异常没问题，使用 lexical_cast(来自 boost 或“伪造”，请参阅代码中链接的其他问题 [与上面的链接相同])，您的代码看起来像这样:

#include <iostream>
#include <sstream>
#include <string>

/* Faked lexical-cast from question:
https://stackoverflow.com/questions/1243428/convert-string-to-int-with-bool-fail-in-c/
*/
template <typename T>
T lexical_cast(const std::string& s)
{
    std::stringstream ss(s);

    T result;
    if ((ss >> result).fail() || !(ss >> std::ws).eof())
    {
        throw std::bad_cast("Bad cast.");
    }

    return result;
}


template <typename T>
T parse_type(void)
{
    std::string input;
    std::getline(std::cin, input);

    return lexical_cast<T>(input);
}

int main(void)
{
    try
    {
        int i = parse_type<int>();
        float f = parse_type<float>();
    }
    catch (const std::exception& e)
    {
        std::cout << e.what() << std::endl;
    }
}

我认为 boost 没有词法转换的非抛出版本，因此我们可以通过捕获 bad_cast 来制作此代码的 true/false 而不是异常版本，如下所示。再一次，这适用于 boost 或自定义词法转换。 (任何执行词法转换并抛出 bad_cast 的东西):

#include <iostream>
#include <sstream>
#include <string>

/* Faked lexical-cast from question:
https://stackoverflow.com/questions/1243428/convert-string-to-int-with-bool-fail-in-c/
*/
template <typename T>
T lexical_cast(const std::string& s)
{
    std::stringstream ss(s);

    T result;
    if ((ss >> result).fail() || !(ss >> std::ws).eof())
    {
        throw std::bad_cast("Bad cast.");
    }

    return result;
}


template <typename T>
bool parse_type(T& t)
{
    std::string input;
    std::getline(std::cin, input);

    try
    {
        t = lexical_cast<T>(input);

        return true;
    }
    catch (const std::bad_cast& e)
    {
        return false;
    }
}

int main(void)
{
    int i;
    if (!parse_type(i))
    {
        std::cout << "Bad cast." << std::endl;
    }
}

现在返回到 bool 结果，除了我们通过使用现有的 lexical_cast 函数避免代码重复。

您当然可以选择要使用的方法。