C++ 从文件中读取并避免空行中的空白

我目前正在做一个项目，我在读命令，我需要避免空白行上的空白。到目前为止，我做得很好，但出于某种原因，我似乎不知道如何让它发挥作用。我想

如果（操作码==“\t”| |操作码==”）继续

会处理，但它没有。如果有人能帮我看看，那就太好了

下面是我正在阅读的命令的一个小示例。它们是[label]操作码[arg1][，arg2]格式

#Sample Input
LA 1,1
LA 2,2
\t <<<<<<<Here just to show that it's a blank line with only a tab
TOP NOP

---

使用std:：stringstream并从行读取std:：string变量。这样，空白将被省略。

[更新] 如果要删除开头的空白，请执行以下操作：

s.erase（s.find_last_not_of（“\n\r\t”）+1）

[UPDATE2]或在阅读时数数单词：

如本例所示：

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

int main() {

  std::string line;
  while (std::getline(std::cin, line))
  {
      std::string lineNoWS = line;
      lineNoWS.erase(lineNoWS .find_last_not_of(" \n\r\t")+1);
      if (lineNoWS.empty())
        std::cout << "EMPTY LINE\n";

      std::string word;
      unsigned words = 0;
      std::istringstream line_is(line);
      while(line_is >> word)
      {
         std::cout << '\'' << word << "'\n"; 
         ++words;
      }
      std::cout << "(" << words << ")ENDLINE\n"; 
  }
}

#包括
#包括
#包括
int main（）{
std：：字符串行；
while（std:：getline（std:：cin，line））
{
std:：string lineNoWS=行；
lineNoWS.erase（lineNoWS.find不是（“\n\r\t”）+1的最后一个）；
if（lineNoWS.empty（））
std:：cout>word）
{
STD::CUT
使用STD:：String String并从您的行读取到STD::String变量。以这种方式，将省略空白。
[更新]
如果要删除开头的空白，请执行以下操作：

s.erase（s.find_last_not_of（“\n\r\t”）+1）；

[UPDATE2]或在阅读时数数单词：

如本例所示：

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

int main() {

  std::string line;
  while (std::getline(std::cin, line))
  {
      std::string lineNoWS = line;
      lineNoWS.erase(lineNoWS .find_last_not_of(" \n\r\t")+1);
      if (lineNoWS.empty())
        std::cout << "EMPTY LINE\n";

      std::string word;
      unsigned words = 0;
      std::istringstream line_is(line);
      while(line_is >> word)
      {
         std::cout << '\'' << word << "'\n"; 
         ++words;
      }
      std::cout << "(" << words << ")ENDLINE\n"; 
  }
}

#包括
#包括
#包括
int main（）{
std：：字符串行；
while（std:：getline（std:：cin，line））
{
std:：string lineNoWS=行；
lineNoWS.erase（lineNoWS.find不是（“\n\r\t”）+1的最后一个）；
if（lineNoWS.empty（））
std:：cout>word）
{
std:：cout您可能应该尝试使命令的读取更“通用”。
假设行有效，则必须以标签开头，并且标签只能包含“字母”，而不能检查“\t”、““\n”、“r”、“#”和（…）
你为什么不直接使用isalpha函数呢

然后需要获取参数，并假设它们由“，”分隔，最好的方法是根据“，”分隔符拆分行

一些示例代码，让您获得“标签”和带有“参数”的向量，我建议您也验证标签（例如，检查标签是否仅由字母组成，并假设您知道“命令”，则验证为特定标签检索的参数的数量和类型

std::ifstream inStream("c:\\data\\dump.txt");   
    if(!inStream.fail())
    {
        while(!inStream.eof())          
        {
            std::string strLine;
            std::getline(inStream, strLine);

            // Label ?
            if( isalpha(strLine[0]))
            {
                int iIndexOf = strLine.find(" ");
                if(iIndexOf != string::npos)
                {
                    std::string strLabel = strLine.substr(0, iIndexOf);

                    // Arguments ?
                    std::vector<std::string> vArguments;
                    std::stringstream ss(strLine.substr(iIndexOf, strLine.size() - iIndexOf));  

                    std::string strArgument;
                    while(std::getline(ss, strArgument, ','))   
                    {                           
                        if(strArgument.size()!=0)                                                           
                            vArguments.push_back(strArgument);
                    }


                    std::cout << "label: " << strLabel << std::endl << "arguments list: ";
                    for(size_t i=0; i<vArguments.size(); i++)
                        std::cout << vArguments[i] << ";";
                    std::cout << std::endl;
                }
                else
                {
                    // No Arguments
                    std::string strLabel = strLine;                                     
                    std::cout << "label: " << strLabel << std::endl;                    
                }
            }           
        }

        inStream.close();
    }

std:：ifstream-inStream（“c:\\data\\dump.txt”）；
如果（！inStream.fail（））
{
而（！inStream.eof（））
{
std：：字符串strLine；
std:：getline（流内、斯特林）；
//标签？
if（isalpha（strLine[0]））
{
int iIndexOf=strLine.find（“”）；
if（iIndexOf！=字符串：：npos）
{
std:：string strLabel=strLine.substr（0，iIndexOf）；
//争论？
std：：向量变量；
std:：stringstream ss（strLine.substr（iIndexOf，strLine.size（）-iIndexOf））；
std：：字符串字符串字符串；
while（std：：getline（ss，strArgument，，'））
{                           
如果（strArgument.size（）！=0）
变量。推回（strArgument）；
}
std:：cout您可能应该尝试使命令的读取更“通用”。
假设行有效，则必须以标签开头，并且标签只能包含“字母”，而不能检查“\t”、““\n”、“r”、“#”和（…）
你为什么不直接使用isalpha函数呢

然后需要获取参数，并假设它们由“，”分隔，最好的方法是根据“，”分隔符拆分行

一些示例代码，让您获得“标签”和带有“参数”的向量，我建议您也验证标签（例如，检查标签是否仅由字母组成，并假设您知道“命令”，则验证为特定标签检索的参数的数量和类型

std::ifstream inStream("c:\\data\\dump.txt");   
    if(!inStream.fail())
    {
        while(!inStream.eof())          
        {
            std::string strLine;
            std::getline(inStream, strLine);

            // Label ?
            if( isalpha(strLine[0]))
            {
                int iIndexOf = strLine.find(" ");
                if(iIndexOf != string::npos)
                {
                    std::string strLabel = strLine.substr(0, iIndexOf);

                    // Arguments ?
                    std::vector<std::string> vArguments;
                    std::stringstream ss(strLine.substr(iIndexOf, strLine.size() - iIndexOf));  

                    std::string strArgument;
                    while(std::getline(ss, strArgument, ','))   
                    {                           
                        if(strArgument.size()!=0)                                                           
                            vArguments.push_back(strArgument);
                    }


                    std::cout << "label: " << strLabel << std::endl << "arguments list: ";
                    for(size_t i=0; i<vArguments.size(); i++)
                        std::cout << vArguments[i] << ";";
                    std::cout << std::endl;
                }
                else
                {
                    // No Arguments
                    std::string strLabel = strLine;                                     
                    std::cout << "label: " << strLabel << std::endl;                    
                }
            }           
        }

        inStream.close();
    }

std:：ifstream-inStream（“c:\\data\\dump.txt”）；
如果（！inStream.fail（））
{
而（！inStream.eof（））
{
std：：字符串strLine；
std:：getline（流内、斯特林）；
//标签？
if（isalpha（strLine[0]））
{
int iIndexOf=strLine.find（“”）；
if（iIndexOf！=字符串：：npos）
{
std:：string strLabel=strLine.substr（0，iIndexOf）；
//争论？
std：：向量变量；
std:：stringstream ss（strLine.substr（iIndexOf，strLine.size（）-iIndexOf））；
std：：字符串字符串字符串；
while（std：：getline（ss，strArgument，，'））
{                           
如果（strArgument.size（）！=0）
变量。推回（strArgument）；
}
Std:：你介意用空白行解释一下吗？我以前使用StrugSuffor，但从来没有像这样删除空白。看看我的更新。我添加了只跳过空白的支持。我想我不知道如何在不改变整个程序的情况下实现这一点。我不理解你的整个程序。你可以吗？使用
line.erase（line.find_last_not_of（“\n\r\t”）+1”）
从一开始就吃掉所有空格？这对您的程序从一开始就跳过所有空格并检查其余空格有效吗？您介意解释一下如何做吗