C++ 检查c+中的合法整数输入+；

所以我看到很多人问这个问题，但网上没有多少可靠的答案。大多数情况下，只需检查是否将整数替换为字符串，但如果输入了浮点数，则会截断下半部分，或者如果整数和字符相互交错，则会截断字符。我需要帮助编写一段代码，检查用户输入，并要求用户在输入无效或无效/无效组合时重试。我认为基本的想法是制作一个字符串，这样它就可以接受任何东西，然后使用sstream进行操作，如果输入是合法的，那么就返回int，但我无法真正检查其他部分。如果有人运行accross或可以帮助我，请将我链接到它。当我知道该做什么时，我会发布我的代码。

C函数

strtol

（以及它的兄弟）将能够告诉您输入到它的字符串是否已完全消耗

 std::string str;
 char *endptr;
 std::cin >> str;
 long x = std::strtol(str.c_str(), &endptr, 0); 
 if (*endptr != 0) 
    cout << "That's not a valid number...";

std:：string str；
char*endptr；
std：：cin>>str；
长x=std:：strtol（str.c_str（），&endptr，0）；
如果（*endptr！=0）
coutC函数
strtol
（及其同级）将能够告诉您输入到它的字符串是否已完全消耗

 std::string str;
 char *endptr;
 std::cin >> str;
 long x = std::strtol(str.c_str(), &endptr, 0); 
 if (*endptr != 0) 
    cout << "That's not a valid number...";

std:：string str；
char*endptr；
std：：cin>>str；
长x=std:：strtol（str.c_str（），&endptr，0）；
如果（*endptr！=0）
cout假设您不能使用
boost:：lexical\u cast
，您可以编写自己的版本：

#include <sstream>
#include <iostream>
#include <stdexcept>
#include <cstdlib>
template <class T1, class T2>
T1 lexical_cast(const T2& t2)
{
  std::stringstream s;
  s << t2;
  T1 t1;
  if(s >> std::noskipws >> t1 && s.eof()) {
    // it worked, return result
    return t1;
  } else {
    // It failed, do something else:
    // maybe throw an exception:
    throw std::runtime_error("bad conversion");
    // maybe return zero:
    return T1();
    // maybe do something drastic:
    exit(1);
  }
}



int main() {
  std::string smin, smax;
  int imin, imax;

  while(std::cout << "Enter min and max: " && std::cin >> smin >> smax) {
    try {
      imin = lexical_cast<int>(smin);
      imax = lexical_cast<int>(smax);
      break;
    } catch(std::runtime_error&) {
      std::cout << "Try again: ";
      continue;
    }
  }

  if(std::cin) {
    std::cout << "Thanks!\n";
  } else {
    std::cout << "Sorry. Goodbye\n";
    exit(1);
  }
}

#包括
#包括
#包括
#包括
模板
T1词汇转换（常数T2和T2）
{
std:：strings；
s>std:：noskipws>>t1和&s.eof（）{
//它起作用了，结果是
返回t1；
}否则{
//失败了，做点别的：
//可能会引发异常：
抛出std:：runtime_错误（“错误转换”）；
//可能返回零：
返回T1（）；
//也许做些激烈的事情：
出口（1）；
}
}
int main（）{
std：：字符串smin，smax；
int-imin，imax；
while（std:：cout>smin>>smax）{
试一试{
imin=词汇转换（smin）；
imax=词汇投射（smax）；
打破
}捕获（标准：：运行时错误&）{
std:：cout假设您不能使用
boost:：lexical\u cast
，您可以编写自己的版本：

#include <sstream>
#include <iostream>
#include <stdexcept>
#include <cstdlib>
template <class T1, class T2>
T1 lexical_cast(const T2& t2)
{
  std::stringstream s;
  s << t2;
  T1 t1;
  if(s >> std::noskipws >> t1 && s.eof()) {
    // it worked, return result
    return t1;
  } else {
    // It failed, do something else:
    // maybe throw an exception:
    throw std::runtime_error("bad conversion");
    // maybe return zero:
    return T1();
    // maybe do something drastic:
    exit(1);
  }
}



int main() {
  std::string smin, smax;
  int imin, imax;

  while(std::cout << "Enter min and max: " && std::cin >> smin >> smax) {
    try {
      imin = lexical_cast<int>(smin);
      imax = lexical_cast<int>(smax);
      break;
    } catch(std::runtime_error&) {
      std::cout << "Try again: ";
      continue;
    }
  }

  if(std::cin) {
    std::cout << "Thanks!\n";
  } else {
    std::cout << "Sorry. Goodbye\n";
    exit(1);
  }
}

#包括
#包括
#包括
#包括
模板
T1词汇转换（常数T2和T2）
{
std:：strings；
s>std:：noskipws>>t1和&s.eof（）{
//它起作用了，结果是
返回t1；
}否则{
//失败了，做点别的：
//可能会引发异常：
抛出std:：runtime_错误（“错误转换”）；
//可能返回零：
返回T1（）；
//也许做些激烈的事情：
出口（1）；
}
}
int main（）{
std：：字符串smin，smax；
int-imin，imax；
while（std:：cout>smin>>smax）{
试一试{
imin=词汇转换（smin）；
imax=词汇投射（smax）；
打破
}捕获（标准：：运行时错误&）{
std：：cout您可以像stol一样使用C++11

try
{
    std::string value = ...;
    long number = std::stol(value); 
}
catch (std::invalid_argument const& e)
{
    // no conversion could be performed
}

注释更新：VisualC++ 11用Visual Studio 2012进行了实现，代码<> STD:：StOO<代码>，作为一个方便的包装，围绕<代码> Sttol <代码> >代码< >代码>。我认为大多数C++ 11实现都可以以最理想的方式定义它，而不是达到“代码> STD:：StrugSuth机械”。n像stol一样使用C++11
try
{
    std::string value = ...;
    long number = std::stol(value); 
}
catch (std::invalid_argument const& e)
{
    // no conversion could be performed
}

注释更新：VisualC++ 11用Visual Studio 2012进行了实现，代码<> STD:：StOO<代码>，作为一个方便的包装，围绕<代码> Sttol <代码> >代码< >代码>。我认为大多数C++ 11实现都可以以最理想的方式定义它，而不是达到“代码> STD:：StrugSuth机械”。不知道标准C++中的任何类是否封装了像java那样的基元类型，但是这里的一个简单的和非常基本的实现看起来像是
class Integer {
   private:
       int value;
       void parse(string);
   public:
       Integer(string);
       int intValue();
};

Integer::Integer(string sint) { parse(sint); }
int Integer::intValue() { return value; }

void Integer::parse(string sint) {
    string::iterator its = sint.begin();
    while(its != sint.end() && (! (*its < '0' || *its > '9'))) {
        its++;
    }
    if(its != sint.end()) {
        throw sint + ": Input is not a valid integer.";
    }
    value = atoi(sint.c_str());
}

类整数{
私人：
int值；
空解析（字符串）；
公众：
整数（字符串）；
int值（）；
};
整数：：整数（字符串sint）{parse（sint）；}
int Integer:：intValue（）{返回值；}
void Integer:：parse（字符串sint）{
string:：iterator its=sint.begin（）；
while（its！=sint.end（）&&（！（*its<'0'|*its>'9'））{
its++；
}
if（its！=sint.end（））{
throw sint+“：输入不是有效的整数。”；
}
value=atoi（sint.c_str（））；
}
 > p>我不知道标准C++中的任何类都封装了像java那样的原始类型，但是这里的一个简单的、非常基本的实现看起来像是

class Integer {
   private:
       int value;
       void parse(string);
   public:
       Integer(string);
       int intValue();
};

Integer::Integer(string sint) { parse(sint); }
int Integer::intValue() { return value; }

void Integer::parse(string sint) {
    string::iterator its = sint.begin();
    while(its != sint.end() && (! (*its < '0' || *its > '9'))) {
        its++;
    }
    if(its != sint.end()) {
        throw sint + ": Input is not a valid integer.";
    }
    value = atoi(sint.c_str());
}

类整数{
私人：
int值；
空解析（字符串）；
公众：
整数（字符串）；
int值（）；
};
整数：：整数（字符串sint）{parse（sint）；}
int Integer:：intValue（）{返回值；}
void Integer:：parse（字符串sint）{
string:：iterator its=sint.begin（）；
while（its！=sint.end（）&&（！（*its<'0'|*its>'9'））{
its++；
}
if（its！=sint.end（））{
throw sint+“：输入不是有效的整数。”；
}
value=atoi（sint.c_str（））；
}
Boost的
lexical_cast
在将双精度表示转换为整数时失败。由于不允许为作业安装外部库，我一直在极力主张不要使用外部库。顺便说一句，我们还是一名学生。在这种情况下，您可以检查整个字符串是否已转换。我知道这里有一个很好的例子omewhere.Boost的
lexical_cast
在将双精度表示转换为整数时失败。由于不允许为作业安装外部库，所以我极力主张不要使用外部库。顺便说一句，我们仍然是学生。在这种情况下，您可以检查整个字符串是否已转换。我知道这里有一个很好的例子这意味着正则整数也不是数字，如果输入了字符或字符串，它就会崩溃。这意味着正则整数也不是数字，如果输入了字符或字符串，它就会崩溃。这似乎是可行的