How to make object from text file C++? - c++

Question

I have to implement polymorphism in my project. I have a virtual class called "Account". Then there are 4 subclasses: USD, EUR, GBP, and CHF.
I need to read the current balance from a text file like this:
USD 50
CHF 80
GBP 10
EUR 90
and make a subclass depending on the currency.
Every currency should have its own object. Later in the program, I will implement currency exchange, exchange rates will be read from the file. I don't have any idea of how to start with these classes. What should I learn?
My code so far:
class Account{
std::string currency;
public:
virtual void balance() = 0;
};
class currencyAcc: public Konto {
std::string currency;
float balance;
walutowe(std::string currency,float balance) {
this->currency= currency;
this->balance= balance;
}
void AccBallance() {
std::cout << balance<< std::endl;
}
};

Answer 1

What should I learn?
Well, if you have covered the basics, you sure need some practice and guidance!
You could have a global function that:
reads a block of text file,
parses and creates the correct object dynamically (based on some condition), and
returns a pointer to the object (cast to the base):
Account * parseOne(std::fstream& file); // Reference to opened file
Even if you just want the code, you will still have to go through an explanation. :)
Let us see it in a general sense.
Read a line
Very simply:
std::getline(file, line);
it. You should also check if the read was successful.
Parse it
You can do this as:
std::stringstream parse_me(line);
parse_me >> some_data_1;
parse_me >> some_data_2;
...
Create your object...
Here, you need to create it on the basis of currency_type. Do:
if(currency_type == "GBP")
{
new_currency_object = new GBP(balance);
}
for each derived class.
...and The Code:
Putting it together:
Account * parseOne(std::fstream& file) // Reference to opened file
{
// To read a line from the file
std::string line;
// If the read failed, return NULL
if(!std::getline(file, line))
{
return 0;
}
// Read success
// Using stringstream so that different types of data can be parsed
std::stringstream line_buffer(line);
// Declare variables to be parsed
std::string currency_type;
float balance;
// Now parse it (note the order!)
line_buffer >> currency_type >> balance;
// Create a pointer to base...
Account * new_currency_object;
// ...and create the object based on the currency_type
if(currency_type == "USD")
{
new_currency_object = new USD(balance);
}
... for each currency
// We are done, return the fruits of our labour
return new_currency_object;
}
(Note that I assume you have a USD(float balance) constructor. If not, set balance yourself)
to be used as:
// open the file
std::fstream currency_file("my_currencies.txt");
// Read a currency
Account * a_currency;
// When the read finishes, we get NULL
while(a_currency = parseOne(currency_file))
{
// do something with a_currency. Maybe:
// list_of_currencies.push_back(a_currency) it?
}
Edit: And be sure to deallocate the memory once done! In fact, use of new and raw pointers are not encouraged anymore. Thanks to this comment for suggesting it.
For further reading, see How to implement the factory method pattern in C++ correctly
.
Good luck!

Answer 2

You need a Currency class that accepts the currency code in the constructor. The object of the Currency class can be part of the account via composition, instead of the current currency with datatype string.