C ++增强型猫

Question

Suppose I have a function from string to string, such as for example:

string identity(string text) {
    return text;
}

How can I print the function applied to input to output, avoiding explicit variables, input and output handling? Something like interact in Haskell.

int main() {
    std::interact(identity);
}

This would really cut down obvious code, and let the algoritmh and the logic stand out instead.

Example usage would be:

$./enhanced_cat
Example
Example
$

Answer 1

template<class F>
struct interacter_t {
  F f;
  void operator()( std::istream& is = std::cin, std::ostream& os = std::cout ) {
    std::string in;
    while( getline( is, in ) ) {
      os << f(std::move(in)) << '\n';
    }
  }
};
template<class F>
interacter_t<std::decay_t<F>> interact( F&& f ) {
  return {std::forward<F>(f)};
}

then:

int main() {
  auto io = interact(identity);
  std::cout << "Start:\n";
  io();
  std::cout << "End.\n";
}

I added the separate invocation to creation of the interactor object.

You can do it on one line:

  std::cout << "Start:\n";
  interact(identity)();
  std::cout << "End.\n";

or you can modify interact to run the interactor_t instead of returning it. I personally like that distinction: creation and execution are different things.

live example .

This version reads everything from the input stream until it ends. Reading less than that is easy, just replace the body of operator() .

Answer 2

You could roll your own interact, something like the below. (Note: probably won't actually compile as is.)

void interact(string (*function)(string))
{
    string input;
    getline(cin, input);
    cout << function(input) << endl;
}

Answer 3

You can easily write such a thing yourself using std::function . Example:

#include <string>
#include <iostream>
#include <functional>

std::string identity(std::string const& text) {
    return text;
}

void interact(std::function<std::string(std::string const&)> f)
{
    std::string input;
    std::getline(std::cin, input);
    std::cout << f(input);
}

int main()
{
    interact(identity);
}

But that certainly doesn't look like idiomatic C++. Even though C++ supports functional programming to a certain extent, it's not a functional programming language, and you should not try to write Haskell in C++.