create objects based on entries from a file - c++

Question

How to create objects during runtime based on input from file.
I have few entries in a file in an organized way separated by a space
entryname type satus
entry1 type1 yes
entry2 type2 no
...
I would like to create objects of below class based on number of entries.
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
class Entry{
std::string name;
std::string type;
std::string availability;
};
void getEntriesInfo(std::vector<std::string> &info)
{
std::string line;
std::fstream myfile("entries.txt",std::ios::in);
if (myfile.is_open())
{
//remove first line from file.
getline(myfile,line);
while ( getline(myfile,line) )
info.push_back(line);
myfile.close();
}
else std::cout << "Unable to open file";
}
int main()
{
std::vector<std::string> entries_info;
getEntriesInfo(entries_info);
for(auto &e: entries_info)
std::cout<<e<<std::endl;
return 0;
}
EDIT 1:
I have restructured code a bit using maps and vectors, can it be made more elegant.
If you look at the code , I have not used constructors & destructors properly, (I could not figure out a good way to use), also the setters and not written all kinds of constructors(deep copy or move) etc..
#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
//#include <istream>
#include <map>
class AItem;
AItem makeItem(std::string );
void displayItemInfo(std::vector<std::string> info);
class Item {
public:
virtual ~Item() = default;
virtual std::string name() const = 0 ;
virtual std::string quota() const = 0 ;
virtual std::string make() const = 0 ;
};
class AItem : Item{
private:
std:: string _name;
std:: string _quota;
std:: string _make;
public:
virtual std::string name() const { return _name;}
virtual std::string quota() const { return _quota;}
virtual std::string make() const {return _make;}
void setName();
void setQuota();
void setMake();
AItem(){}
AItem(std::string name,std::string quota,std::string make) :_name(name),_quota(quota),_make(make) {}
friend std::istream& operator>>(std::istream& in,AItem& item);
friend std::ostream & operator << (std::ostream &out, const AItem & item);
};
void displayItemInfo(std::vector<std::string> info)
{
for(auto &i_it:info)
std::cout<<i_it<<std::endl;
}
std::vector<std::string> readItemInfo(const char *str)
{
std::string line;
std::vector<std::string> itemInfo;
std::ifstream file(str, std::ios::in);
if(file.is_open()){
getline(file,line);
while(getline(file,line))
itemInfo.push_back(line);
file.close();
}else{
std::cout<<"Unable to open"<<str<<std::endl;
}
return itemInfo;
}
std::ostream &operator << (std::ostream &out,const AItem& item)
{
//std::cout <<item.name()<<" "<<item.quota()<<" "<<item.make() <<std::endl;
return out <<item.name()<<" "<<item.quota()<<" "<<item.make() <<std::endl;
}
std::istream& operator >> (std::istream& in,AItem& item) {
//in >> item._name >> item._quota >> item._make;
return in >> item._name >> item._quota >> item._make;
}
AItem makeItem(std::string aitem)
{
std::stringstream ss(aitem);
std::vector<std::string> arguments;
std::string entry;
while (ss >> entry) {
arguments.push_back(entry);
}
AItem aItem_obj(arguments.at(0),arguments.at(1),arguments.at(2));
return aItem_obj;
}
std::map<std::string,AItem> createItems(std::vector<std::string> item)
{
std::map<std::string,AItem> ItemMap;
for(auto &i_it:item) {
AItem a_item = makeItem(i_it);
ItemMap.insert(std::make_pair(a_item.name(),a_item));
}
// for(auto &m:ItemMap)
// std::cout<<m.first<<m.second<<std::endl;
return ItemMap;
}
int main(int argc, char*argv[])
{
char *str = "player_info.txt";
std::vector<std::string> info;
std::map<std::string,AItem> ItemMap;
// info = readItemInfo(str);
// displayItemInfo(info);
//#if 0
ItemMap = createItems(readItemInfo(str));
for(auto &item:ItemMap)
std::cout<<item.first<<item.second<<std::endl;
//#endif
return 0;
}
EDIT 2
I have done this way
entry.h
#include <iostream>
#include <string>
class Entry{
private:
std::string name;
std::string type;
std::string availability;
public:
std::string getName(void) const;
std::string getType(void) const;
std::string getAvailability(void) const;
void setName(const std::string n);
void setType(const std::string t);
void setAvailability(const std::string y);
Entry();
~Entry();
friend std::ostream &operator << (std::ostream &out,const Entry &e);
};
entry.cpp
#include "entry.h"
std::string Entry ::getName(void) const{
return name;
}
std::string Entry ::getType(void) const{
return type;
}
std::string Entry ::getAvailability(void) const{
return availability;
}
void Entry ::setName(const std::string n){
name = n;
}
void Entry ::setType(const std::string t){
type = t;
}
void Entry ::setAvailability(const std::string y){
availability = y;
}
Entry::Entry(){
}
Entry::~Entry(){
}
std::ostream &operator << (std::ostream &out,const Entry &e){
return out << e.getName()<<" " <<e.getType()<<" "<<e.getAvailability()<<std::endl;
}
main.cpp
#include <fstream>
#include <vector>
#include "entry.h"
void makeEntry(std::string line,std::vector<Entry> &entries)
{
Entry P1;
P1.setName(line.substr(0, line.find(' ')));
P1.setType(line.substr(P1.getName().size(), line.find(' ')));
P1.setAvailability(line.substr(P1.getName().size()+P1.getType().size(), line.find(' ')));
//std::cout<<"C:"<<P1.getName()<<P1.getType()<<P1.getAvailability()<<std::endl;
entries.push_back(P1);
}
void getEntriesInfo(std::vector<std::string> &info)
{
std::string line;
std::fstream myfile("entries.txt",std::ios::in);
if (myfile.is_open())
{
//remove first line from file.
getline(myfile,line);
while ( getline(myfile,line) )
info.push_back(line);
myfile.close();
}
else std::cout << "Unable to open file";
}
int main()
{
std::vector<std::string> entries_info;
std::vector<Entry> entries;
getEntriesInfo(entries_info);
for(auto &e: entries_info) {
std::cout<<e<<std::endl;
makeEntry(e,entries);
}
std::cout<<"OUT"<<std::endl;
for(auto &e: entries) {
std::cout<<e<<std::endl;
}
return 0;
}

Answer 1

You can provide an overload for the stream extraction operator:
std::istream& operator>>(std::istream& in,Entry& e) {
in >> e.name >> e.type >> e.availability;
}
This works, when the individual entries in the file do not contain spaces. Ie it would fail for
entryName LastName type1 yes
In this case you would need to have a seperator (eg ;) and use std::getline to parse the lines.
Reading entries into a vector is then (assuming you know the number of entries beforehand):
std::vector<Entry> readFromFile(std::istream& myfile,size_t n_entries) {
std::vector<Entry> entries;
data.resize( n_entries );
for (auto& e : entries ) myfile >> e;
return entries;
}