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 
} 

---

根据您的评论（“手头任务是一个简单的程序：取两个用户输入整数，并将其添加输入限制只有整数i。可以在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; 
    } 
} 

我不认为有提升词汇蒙上了无抛出的版本，所以我们可以通过捕捉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)