Fast input (tools/cin.hpp)

• View this file on GitHub
• View document part on GitHub
• Last update: 2023-05-02 20:12:48+09:00
• Include: #include "tools/cin.hpp"
• Link: https://nyaannyaan.github.io/library/misc/fastio.hpp.html

It provides very restricted but fast input functions.

Constraints

• You cannot include this header file from more than one compilation unit.

License

• CC0 1.0 Universal

Author

• Nyaan

tools::cin

tools::istream cin;

It is an interface to the input functions.

tools::istream::operator>>

(1) tools::istream& cin.operator>>(char& c);
(2) tools::istream& cin.operator>>(std::string& s);
(3) template <typename T> tools::istream& cin.operator>>(T& x);

• (1)
  • It reads one character from standard input, sets the value to c and returns cin.
• (2)
  • We can express the entire string not yet read from standard input in the form of the regular expression ([ \n]*)([^ \n]*).*. It reads the first and second groups from standard input, sets the second group to s and returns cin.
• (3)
  • If we can express the entire string not yet read from standard input in the form of the regular expression ([ \n]*)(-?[0-9]+).*, it reads the first and second groups from standard input, sets the integer parsed from the second group to x and returns cin.

Constraints

• (1)
  • You cannot read standard input by any other ways except for tools::cin in the program.
  • There are at least one character not yet read from standard input.
• (2)
  • You cannot read standard input by any other ways except for tools::cin in the program.
• (3)
  • You cannot read standard input by any other ways except for tools::cin in the program.
  • <T> is a built-in integral type.
  • If <T> is signed:
    • The entire string not yet read from standard input matches the regular expression ^[ \n]*-?[0-9]+.
    • -std::numeric_limits<T>::max() $\leq v \leq$ std::numeric_limits<T>::max() where $v$ is the value that will be read.
  • If <T> is unsigned:
    • The entire string not yet read from standard input matches the regular expression ^[ \n]*[0-9]+.
    • $0 \leq v \leq$ std::numeric_limits<T>::max() where $v$ is the value that will be read.

Time Complexity

• (1), (3)
  • $O(1)$
• (2)
  • $O(|v|)$ where $v$ is the value that will be read

Verified with

• tests/fastio/integer.test.cpp
• tests/fastio/string.test.cpp

Code

#ifndef TOOLS_CIN_HPP
#define TOOLS_CIN_HPP

#include <cstring>
#include <cstdio>
#include <string>
#include <algorithm>
#include <type_traits>
#include <iostream>
#include <utility>

// Source: https://nyaannyaan.github.io/library/misc/fastio.hpp.html
// License: CC0 1.0 Universal
// Author: Nyaan

namespace tools {
  namespace detail {
    namespace istream {
      static constexpr int SZ = 1 << 17;
      char inbuf[SZ];
      int in_left = 0;
      int in_right = 0;

      void load() {
        const int len = in_right - in_left;
        ::std::memmove(inbuf, inbuf + in_left, len);
        in_right = len + ::std::fread(inbuf + len, 1, SZ - len, stdin);
        in_left = 0;
      }

      void skip_space() {
        if (in_left + 32 > in_right) load();
        while (inbuf[in_left] <= ' ') in_left++;
      }

      void rd(char& c) {
        if (in_left + 32 > in_right) load();
        c = inbuf[in_left++];
      }

      void rd(::std::string& s) {
        for (; (in_left < in_right || (load(), in_left < in_right)) && (inbuf[in_left] == ' ' || inbuf[in_left] == '\n'); ++in_left);
        s.clear();
        if (in_left == in_right) return;
        int real_size = 0;
        do {
          int to;
          for (to = in_left; to < in_right && inbuf[to] != ' ' && inbuf[to] != '\n'; ++to);
          const int new_real_size = real_size + (to - in_left);
          if (int(s.size()) < new_real_size) {
            s.resize(::std::max(new_real_size, int(s.size()) * 2));
          }
          ::std::memcpy(s.data() + real_size, inbuf + in_left, to - in_left);
          in_left = to;
          real_size = new_real_size;
        } while (in_left == in_right && (load(), in_left < in_right));
        s.resize(real_size);
      }

      template <typename T>
      void rd(T& x) {
        if (in_left + 32 > in_right) load();
        char c;
        do {
          c = inbuf[in_left++];
        } while (c < '-');
        [[maybe_unused]] bool minus = false;
        if constexpr (::std::is_signed_v<T>) {
          if (c == '-') {
            minus = true;
            c = inbuf[in_left++];
          }
        }
        x = 0;
        while (c >= '0') {
          x = x * 10 + (c & 15);
          c = inbuf[in_left++];
        }
        if constexpr (::std::is_signed_v<T>) {
          if (minus) x = -x;
        }
      }
    }
  }

  struct istream {
    template <typename... Args>
    ::tools::istream& operator>>(Args&&... args) {
      ::tools::detail::istream::rd(::std::forward<Args>(args)...);
      return *this;
    }
  };

  ::tools::istream cin;
}

#endif

#line 1 "tools/cin.hpp"



#include <cstring>
#include <cstdio>
#include <string>
#include <algorithm>
#include <type_traits>
#include <iostream>
#include <utility>

// Source: https://nyaannyaan.github.io/library/misc/fastio.hpp.html
// License: CC0 1.0 Universal
// Author: Nyaan

namespace tools {
  namespace detail {
    namespace istream {
      static constexpr int SZ = 1 << 17;
      char inbuf[SZ];
      int in_left = 0;
      int in_right = 0;

      void load() {
        const int len = in_right - in_left;
        ::std::memmove(inbuf, inbuf + in_left, len);
        in_right = len + ::std::fread(inbuf + len, 1, SZ - len, stdin);
        in_left = 0;
      }

      void skip_space() {
        if (in_left + 32 > in_right) load();
        while (inbuf[in_left] <= ' ') in_left++;
      }

      void rd(char& c) {
        if (in_left + 32 > in_right) load();
        c = inbuf[in_left++];
      }

      void rd(::std::string& s) {
        for (; (in_left < in_right || (load(), in_left < in_right)) && (inbuf[in_left] == ' ' || inbuf[in_left] == '\n'); ++in_left);
        s.clear();
        if (in_left == in_right) return;
        int real_size = 0;
        do {
          int to;
          for (to = in_left; to < in_right && inbuf[to] != ' ' && inbuf[to] != '\n'; ++to);
          const int new_real_size = real_size + (to - in_left);
          if (int(s.size()) < new_real_size) {
            s.resize(::std::max(new_real_size, int(s.size()) * 2));
          }
          ::std::memcpy(s.data() + real_size, inbuf + in_left, to - in_left);
          in_left = to;
          real_size = new_real_size;
        } while (in_left == in_right && (load(), in_left < in_right));
        s.resize(real_size);
      }

      template <typename T>
      void rd(T& x) {
        if (in_left + 32 > in_right) load();
        char c;
        do {
          c = inbuf[in_left++];
        } while (c < '-');
        [[maybe_unused]] bool minus = false;
        if constexpr (::std::is_signed_v<T>) {
          if (c == '-') {
            minus = true;
            c = inbuf[in_left++];
          }
        }
        x = 0;
        while (c >= '0') {
          x = x * 10 + (c & 15);
          c = inbuf[in_left++];
        }
        if constexpr (::std::is_signed_v<T>) {
          if (minus) x = -x;
        }
      }
    }
  }

  struct istream {
    template <typename... Args>
    ::tools::istream& operator>>(Args&&... args) {
      ::tools::detail::istream::rd(::std::forward<Args>(args)...);
      return *this;
    }
  };

  ::tools::istream cin;
}

Back to top page