trjhtr

I have been programming in C++ for less than six months, so please correct anything you can.

I think one of the most annoying things programmers have to deal with is validating user input. For instance, if my program says:

Enter a number between 0 and 5

If the user keeps entering 7, the program will not work properly, so a data validation method must be implemented. It could be checking if the input is within range, or we could just try and catch. However, we would have to write different code for different variables and conditions. So, I tried to create a generic method:

#include <iostream>

void manage_input(auto & x, auto lambda_cond,
 std::string in_msg, std::string err_msg) 

One way we could use it is the following:

int main() 
 int x;
 auto lambda_cond = (int x) return x < 5;;
 std::string in_msg = "[x]: ";
 std::string err_msg = "Error! x must be less than 5!n";

 // Make sure that x is less than 5.
 manage_input(x, lambda_cond, in_msg, err_msg);

 // Print a number that is less than 5.
 std::cout << x << "n";

 return 0;

Now, there are many things wrong with this method:

1. It does not support strings with spaces.


2. If a string is entered, the error message will be displayed up to the number of characters in the string.

Another thing is that I do not know how efficient this program is in terms of resource consumption.

Questions:

1. Is this method at least a little bit efficient? How can it be more efficient?


2. Is there a standard way to validate user input? If so, which is it?

I have read about other methods, for example:

• 
  This one, which works for integers only.


• 
  This one, which I might actually implement in the method defined above.

NOTE: When I talk about an efficient solution, I am talking about portable and reusable method that can reliably handle inputs of different data types given certain constraints without sacrificing performance.

It would be portable in the sense that it is OS agnostic and does not depend on code that is not in the standard library. It would be reusable in the sense that it can work with all data types without producing errors. It would not sacrifice performance in the sense that it would not run unnecessary steps.