Get values from user from different cin using a template - c++

Question

I have to create the required function template prompt which displays a supplied string and then returns a value of the templated type. Finally, add a line which calls this function with the string "What is the answer? " (note the trailing space) and stores this answer in the misc field of the supplied struct.
I have no idea what I am doing, please help!
#include <string>
#include <iostream>
using std::string;
struct Answers {
string name;
float answer;
int misc;
};
// write template function "prompt" here
**template <class T>
void prompt(string prompt_question, T& answer)
{
prompt_question = "What is the answer? ";
cin >> answer;
misc = answer;
}**
// what should I have written?
int main(int argc, char* argv[])
{
**using namespace std;
Answers info {
prompt<string>("What is your name? "),
prompt<float>(argv[2]),
};**
cout << '\n' << "Who: " << info.name;
cout << '\n' << "Knowledge: " << info .answer;
cout << '\n' << "Wisdom: " << info.misc;
return 0;
}
I feel stupid for not knowing how to solve it, been trying to figure it out since 7 est. Please help
Things between ** are the only things I can edit unfortunately

Answer 1

IMHO, that attempt of OP was not so lucky.
I try to sort it out:
template <class prompt> prompt(string prompt_question)
That's broken. The identifier of function is missing. Or, may be, the return type of function is missing but then the name of the function is the same as the identifier of template parameter.
prompt_question = answer;?
What shall this be good for?
answer is not declared in this scope nor initialized.
Why prompt_question shall be overridden with it?
answer = "What is the answer??
What shall this be good for?
misc = answer;?
What shall this be good for?
misc is not declared in this scope.
My working sample to show how this could look like:
#include <cassert>
#include <iostream>
struct Answers {
std::string name;
float answer;
int misc;
};
template <class T>
void prompt(const std::string &question, T &answer)
{
std::cout << question;
std::cin >> answer;
}
int main()
{
Answers info { };
prompt("Who: ", info.name);
if (!std::cin) { std::cerr << "Input failed!\n"; return -1; }
prompt("Age: ", info.answer);
if (!std::cin) { std::cerr << "Input failed!\n"; return -1; }
std::cout << "\nYou claim to be " << info.name << " with an age of " << info.answer << ".\n";
}
Output:
Who: Just
Age: 34
You claim to be Just with an age of 34.
Live Demo on coliru
After Edit it seems, the OP requires that template parameter is the return type:
#include <cassert>
#include <iostream>
struct Answers {
std::string name;
float answer;
int misc;
};
template <class T>
T prompt(const std::string &question)
{
std::cout << question;
T answer;
std::cin >> answer;
return answer;
}
int main(int argc, char **argv)
{
Answers info {
prompt<std::string>("Who: "),
prompt<float>("Age: ")
};
if (!std::cin) { std::cerr << "Input failed!\n"; return -1; }
std::cout << "\nYou claim to be " << info.name << " with an age of " << info.answer << ".\n";
}
Output:
Who: Just
Age: 34
You claim to be Just with an age of 34.
Live Demo on coliru
Comparing first and second approach, you will notice a design weakness of the second:
While in the first approach, the type can be deduced by the compiler, this is not possible in the second. The only difference of template instances of second template function prompt() will be the return type – not deducible for compiler. Hence, the second template function must be used with an explicit template parameter always (which introduces another opportunity to make something wrong).
A general recommendation:
When you attempt to write a template function and you are uncertain about templates then start with a plain function, and a typedef for the type which shall become a template parameter:
typedef std::string T;
void prompt(const std::string &question, T &answer)
{
std::cout << question;
std::cin >> answer;
}
Compiling, testing, admiring, done.
Now, it can be turned into a template function:
//typedef std::string T; // obsolete
template <class T>
void prompt(const std::string &question, T &answer)
{
std::cout << question;
std::cin >> answer;
}
Compiling, testing, admiring, done.

Answer 2

If I understand correctly you can use operator>> overloading:
struct AnimalNameAnswer
{
std::string animalName;
};
std::istream& operator>>(std::istream& in, AnimalNameAnswer& ana)
{
return in >> ana.animalName;
}
struct CarSpeedAnswer
{
int MPH;
};
std::istream& operator>>(std::istream& in, CarSpeedAnswer& csa)
{
return in >> cas.MPH;
}
template<class ANSWER>
void prompt(ANSWER& a)
{
std::cout << "Enter answer:" << std::endl;
std::cin >> a;
}