Administrace komentářů

To bude tím, že jsem to nezkoušel. :-) Jinak by tento jednoúčelový prográmek šel samozřejmě napsat jednodušeji, ale předpokládám, že s těmi hodnotami budete chtít pracovat nějak soustavněji, takže spíš než na jednoduchost implementace té třídy jsem se zaměřil na jednoduchost použití. Zrovna tak místo konstanty 'std::numeric_limits<std::streamsize>::max()' jsem mohl napsat třeba 256, ale IMHO je lepší si na podobné bulharské konstanty nezvykat a psát všude to, co tam logicky patří. Takže druhý pokus:

#include <iostream>
#include <fstream>
#include <stdexcept>
#include <unistd.h> // sleep

class Netload {
public:
  typedef unsigned long long count_t;
  std::string name;
  count_t d;
  count_t u;

  Netload() { d = u = 0; }
  Netload(std::string& iname, count_t id = 0, count_t iu = 0)
    : name(iname) { d = id; u = iu; }
  ~Netload() {}

  const Netload operator - (const Netload& x);
};

inline const Netload Netload::operator - (const Netload& x)
{
  return Netload(name, d - x.d, u - x.u);
}

inline void trimleft(std::string& s)
{
  unsigned i = 0;
  unsigned L = s.length();
  while (i<L && s[i]==' ') i++;
  s.erase(0, i);
}

std::istream& operator >> (std::istream& s, Netload& x)
{
  getline(s, x.name, ':');
  if (!s) return s;
  trimleft(x.name);
  s >> x.d;
  Netload::count_t tmp;
  for (int i=0; i<7; i++)
    s >> tmp;
  s >> x.u;
  s.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
  return s;
}

std::ostream& operator << (std::ostream& s, const Netload& x)
{
  s << x.name << ": dn " << x.d/1024 << " KB, up " << x.u/1024 << " KB\n";
  return s;
}


void GetStat(const std::string& ifname, Netload& stat)
{
  std::ifstream s("/proc/net/dev");
  if (!s) throw std::runtime_error("cannot open /proc/net/dev");

  s.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
  s.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
  while (s >> stat) {
    if (stat.name == ifname) return;
  }

  throw std::runtime_error("cannot read statistics for selected interface");
}


int main(int argc, char** argv)
{
  try {
    if (argc != 2)
      throw std::runtime_error("Usage: transfer <ifname>");

    Netload before, now;

    GetStat(argv[1], before);
    sleep(1);
    GetStat(argv[1], now);

    std::cout << (now - before);
    return 0;
  }
  catch(std::exception& e) {
    std::cerr << "transfer: " << e.what() << std::endl;
    return 1;
  }
}

Tou elegancí jsem myslel hlavně to, jak se vám zpřehlední právě main() a zejména zpracování chyb. Díky použití nástrojů jazyka C++ můžete totiž oddělit reakci na chybu od její detekce.