C++ 希望从std:：count参数中排除行

目前正在使用：

{
std::ifstream inFile("test.txt");
int x = std::count(std::istreambuf_iterator<char>(inFile), std::istreambuf_iterator<char>(), '\n');

cout<<x<<endl;
}

{
std:：ifstream infle（“test.txt”）；
int x=std:：count（std:：istreambuf_迭代器（infle），std:：istreambuf_迭代器（），'\n'）；
cout我认为在这些行上迭代并使用谓词函数将是一种方式
我认为在这些行上迭代并使用谓词函数将是一种方式
我认为在这些行上迭代并使用谓词函数将是一种方式
我认为在这些行上迭代并使用谓词函数你可以设置一个过滤流buf，丢弃以
/
开头的行。流应该环绕
infle的文件缓冲区。James Kanze在他的中做了类似的事情：
你可以设置一个过滤流buf，丢弃以
/
开头的行。流应该环绕
infle
的文件缓冲区。James Kanze在他的中做了类似的事情：
您可以设置一个过滤流buf，它丢弃以
/
开头的行。流应该环绕
infle
的文件缓冲区。James Kanze在他的中做了类似的事情：
您可以设置一个过滤流buf，它丢弃以
/
开头的s行。流应该环绕
infle
的文件缓冲区。James Kanze在他的中做了类似的事情：
首先，你需要逐行读取文件。有一种很好的方法可以通过读取来完成。其次，你需要使用
std:：count\u if
，这样你就可以传递一个谓词，该谓词将终止该行是否以注释序列开头

#include <string>
#include <vector>
#include <iostream>
#include <fstream>

#include <boost/algorithm/string/predicate.hpp>

class line
{
  std::string data;

public:
  friend std::istream& operator>>(std::istream& is, line& l)
  {
    std::getline(is, l.data);
    return is;
  }

  operator std::string() const
  {
    return data;
  }
};

int main()
{
  std::ifstream file("./test.txt");

  auto count = std::count_if(std::istream_iterator<line>(file),
                             std::istream_iterator<line>(), [](const line& l) {
    return !boost::algorithm::starts_with(static_cast<std::string>(l), "//");
  });

  std::cout << count << std::endl;

  return 0;
}

#包括
#包括
#包括
#包括
#包括
班级线
{
std：：字符串数据；
公众：
friend std:：istream&operator>>（std:：istream&is，line&l）
{
std:：getline（is，l.data）；
回报是；
}
运算符std:：string（）常量
{
返回数据；
}
};
int main（）
{
std:：ifstream文件（“./test.txt”）；
自动计数=std:：count\u if（std:：istream\u迭代器（文件），
std:：istream_迭代器（），[]（常量行和l）{
return！boost:：algorithm:：以（static_cast（l），“/”）开头；
});
std:：cout首先，您需要逐行读取文件。有一种很好的方法可以通过a来完成。其次，您需要使用
std:：count\u if
，以便您可以传递一个谓词，该谓词将确定行是否以注释序列开头

#include <string>
#include <vector>
#include <iostream>
#include <fstream>

#include <boost/algorithm/string/predicate.hpp>

class line
{
  std::string data;

public:
  friend std::istream& operator>>(std::istream& is, line& l)
  {
    std::getline(is, l.data);
    return is;
  }

  operator std::string() const
  {
    return data;
  }
};

int main()
{
  std::ifstream file("./test.txt");

  auto count = std::count_if(std::istream_iterator<line>(file),
                             std::istream_iterator<line>(), [](const line& l) {
    return !boost::algorithm::starts_with(static_cast<std::string>(l), "//");
  });

  std::cout << count << std::endl;

  return 0;
}

#包括
#包括
#包括
#包括
#包括
班级线
{
std：：字符串数据；
公众：
friend std:：istream&operator>>（std:：istream&is，line&l）
{
std:：getline（is，l.data）；
回报是；
}
运算符std:：string（）常量
{
返回数据；
}
};
int main（）
{
std:：ifstream文件（“./test.txt”）；
自动计数=std:：count\u if（std:：istream\u迭代器（文件），
std:：istream_迭代器（），[]（常量行和l）{
return！boost:：algorithm:：以（static_cast（l），“/”）开头；
});
std:：cout首先，您需要逐行读取文件。有一种很好的方法可以通过a来完成。其次，您需要使用
std:：count\u if
，以便您可以传递一个谓词，该谓词将确定行是否以注释序列开头

#include <string>
#include <vector>
#include <iostream>
#include <fstream>

#include <boost/algorithm/string/predicate.hpp>

class line
{
  std::string data;

public:
  friend std::istream& operator>>(std::istream& is, line& l)
  {
    std::getline(is, l.data);
    return is;
  }

  operator std::string() const
  {
    return data;
  }
};

int main()
{
  std::ifstream file("./test.txt");

  auto count = std::count_if(std::istream_iterator<line>(file),
                             std::istream_iterator<line>(), [](const line& l) {
    return !boost::algorithm::starts_with(static_cast<std::string>(l), "//");
  });

  std::cout << count << std::endl;

  return 0;
}

#包括
#包括
#包括
#包括
#包括
班级线
{
std：：字符串数据；
公众：
friend std:：istream&operator>>（std:：istream&is，line&l）
{
std:：getline（is，l.data）；
回报是；
}
运算符std:：string（）常量
{
返回数据；
}
};
int main（）
{
std:：ifstream文件（“./test.txt”）；
自动计数=std:：count\u if（std:：istream\u迭代器（文件），
std:：istream_迭代器（），[]（常量行和l）{
return！boost:：algorithm:：以（static_cast（l），“/”）开头；
});
std:：cout首先，您需要逐行读取文件。有一种很好的方法可以通过a来完成。其次，您需要使用
std:：count\u if
，以便您可以传递一个谓词，该谓词将确定行是否以注释序列开头

#include <string>
#include <vector>
#include <iostream>
#include <fstream>

#include <boost/algorithm/string/predicate.hpp>

class line
{
  std::string data;

public:
  friend std::istream& operator>>(std::istream& is, line& l)
  {
    std::getline(is, l.data);
    return is;
  }

  operator std::string() const
  {
    return data;
  }
};

int main()
{
  std::ifstream file("./test.txt");

  auto count = std::count_if(std::istream_iterator<line>(file),
                             std::istream_iterator<line>(), [](const line& l) {
    return !boost::algorithm::starts_with(static_cast<std::string>(l), "//");
  });

  std::cout << count << std::endl;

  return 0;
}

#包括
#包括
#包括
#包括
#包括
班级线
{
std：：字符串数据；
公众：
friend std:：istream&operator>>（std:：istream&is，line&l）
{
std:：getline（is，l.data）；
回报是；
}
运算符std:：string（）常量
{
返回数据；
}
};
int main（）
{
std:：ifstream文件（“./test.txt”）；
自动计数=std:：count\u if（std:：istream\u迭代器（文件），
std:：istream_迭代器（），[]（常量行和l）{
return！boost:：algorithm:：以（static_cast（l），“/”）开头；
});
std:：可能
std:：acculate
使用基于行的迭代器并在累加器函数内计数。可能
std:：acculate
使用基于行的迭代器并在累加器函数内计数。可能
std:：acculate
使用基于行的迭代器并在累加器函数内计数。可能
std:：使用基于行的迭代器累加
，并在累加器函数中计数。