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做到这一点，我也在考虑这些。如果num1！= type（int）：print“你没输入整数，请输入一个整数。”否则：继续“），你想要这样的东西：

#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（来自提升或“伪造”，请参阅代码中链接的其他问题[与上述链接相同]），您的代码看起来像这样：

#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来创建此代码的真/假而非异常版本，如下所示。再次，这适用于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函数来避免代码重复。

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

Answer 2

C ++是一种静态类型语言，这意味着编译器始终知道变量的类型。因此，为了声明var，你必须为它指定一个类型，这使你发布的if语句没有实际意义。如果你能描述一下你想要完成的任务，可能还有另一条路可以解决你的问题。

Answer 3

这是正确的，需要更多信息，如果你正在寻找Java的“instanceOf”运算符，除非你使用RTTI和typeid，否则没有一个。

Answer 4

你的意思是你有一个浮点值并想知道它是否是一个整数？

在这种情况下，试试这个：

#include <math.h>

//...

double x = 5.0;
if(round(x) == x) {
   // x has an integer value
}

或者，如果该值是某些计算的结果，则可能存在小的舍入误差。然后尝试这样的事情：

double x = 4.99999999999;
if(abs(round(x) - x) < 1e-8)

C ++语法问题：if var！= type int

4 个答案: