Textdateien in Objekte einer Klasse umwandeln und in Vector ablegen....

[travelflo22]

Hallo,

ich stehe mal wieder etwas auf den Schlauch und brauche einen Denkanstoß Ich hab zu der Aufgabe schon zu einem anderen Problem etwas gepostet - ich wiederhols hier nochmal kurz. Also ich hab da eine Klasse welche ein Ascii-Objekt beschreibt, man kann mittels der Klasse verschiedene Funktion mit dem Objekt machen. U.a Zeilen hinzufügen oder durch das Überladen von Relationen Objekte diesen Typs vergleichen...

Bisher konnte ich eine Datei einlesen und 1 Objekt daraus erzeugen, in dem ich den Inputfilestream zeileweise auslese und die Zeilen dem Objekt zufügen...

Nun möchte ich meiner Klasse aber mehrer Textdateien (Pfade) übergeben können, Ich möchte also das jeweils eine Textdatei zu einem Objekt vom Typ meiner Klasse wird...und diese Objekte möchte ich in einem Container ablegen..

nun bin ich am umsetzen.. und weiß nicht wie ich es machen soll, dass ich Datei-abhängig einlesen kann.. sollte ich das Einlesen mit in die Klasse einbauen? anstatt wie jetzt das Objekt von außen einzeln mit Zeilen zu "füttern"?

Habe sowas noch nicht gemacht und bräuchte mal nen paar gute Ideen..

Als anhang mal der Quellcode.. zu erst der Header mit der Klasse, dann eine cpp welche den Header vervollständigt und eine cpp, welche die main-methode enthält, das Objekt erzeugt hat und noch ein Rahmen um das Objekt legt sowie es ausgibt...

Header:

//Includeguard ASCIIPICTURE//
#if !defined(ASCIIPICTURE_H)
#define ASCIIPICTURE_H 
#include <vector>
#include <string>
#include <istream>
#include <ostream>
///////////////////////////

class AsciiPicture
{

private:
	typedef std::vector<std::string> linesvector;
	linesvector lines;

public:

	AsciiPicture(); //DefaultKonstruktor

	//Typedefs für Linesvector///////////////////////////////////
	typedef linesvector::size_type size_type; //wie unsigned int
	typedef linesvector::iterator iter;
	typedef linesvector::const_iterator const_iter;
	////////////////////////////////////////////////////////////

	//Zeile hinzufügen
	void add_line(const std::string& text); 

	//Zeile an bestimmter Postion hinzufügen
	void add_line(const std::string& text, size_type pos);

	//Zeile an bestimmter Position löschen
	void delete_line (size_type pos);

	//Bestimmte Zeile zurückgeben
	std::string& get_line(size_type pos){
		return lines.at(pos);
		}

	const std::string& get_line(size_type pos)const {
		return lines.at(pos);
		}

	//Bestimmen der maximalen Spaltenbreite
	size_type get_column ()const{ 
		std::string::size_type max=0;
		linesvector::const_iterator beginline=lines.begin();
		linesvector::const_iterator endline=lines.end();
		while(beginline!=endline) {
			if (max < (*beginline).size()){
				max=(*beginline).size();
			}	
			++beginline;
		}
		return max;
	}

	//Ermitteln der Anzahl der Zeilen
	size_type get_row()const{return lines.size();}
	////////////////////////////////////////////////////////////////////

	//Iteratoren und Const-Iteratoren für Anfang und Ende im LinesVector lines//
	iter begin(){return lines.begin();}
	iter end(){return lines.end();}
	const_iter begin() const{return lines.begin();}
	const_iter end() const{return lines.end();}
	///////////////////////////////////////////////////////////////////////////

	///Operator[]-Zugriff//////////////////////////////////////////////////////
	std::string& operator[](unsigned int i){

		return get_line(i);

	}

	const std::string& operator[] (unsigned int i)const {

		return get_line(i);
	}
	/////////////////////////////////////////////////////////////////////////////

	///Operatoren-Überladung///////////////////////////////////////////////////
	inline bool operator < (AsciiPicture& rhs)
	{
		return get_row() < rhs.get_row(); 
	}

	inline bool operator <= (AsciiPicture& rhs)
	{
		return get_row() <= rhs.get_row(); 
	}

	inline bool operator > (AsciiPicture& rhs)
	{
		return get_row() > rhs.get_row(); 
	}

	inline bool operator >= (AsciiPicture& rhs)
	{
		return get_row() >= rhs.get_row(); 
	}
};

#endif

cpp für header

#include "AsciiPicture.h"

//Default Konstruktor, erzeugt eine Instanz der Klasse AsciiPicture
AsciiPicture::AsciiPicture(){}

//Zeile hinzufügen
void AsciiPicture::add_line(const std::string& text)
{
	lines.push_back(text);
}

//Zeile an bestimmter Postion hinzufügen
void AsciiPicture::add_line(const std::string& text, size_type pos)
{
	linesvector::iterator iter=lines.begin()+pos;
	lines.insert(iter, text);
}

//Zeile an bestimmter Position löschen
void AsciiPicture::delete_line (size_type pos)
{
	lines.erase(lines.begin()+pos); //setzt Iterator auf die Position und löscht
}

///Operatoren-Überladung//////////////////////////////////////////////////////
/*bool AsciiPicture::operator> (const AsciiPicture& rhs)
{
	return operator> (rhs->lines.size(), *this->lines.size());
}*/

cpp mit main-method

#include <vector>
#include <string>
#include <iterator>
#include <iostream>
#include <fstream> 
#include "AsciiPicture.h"

void input(AsciiPicture& asciipicture);
void frame (AsciiPicture& asciipicture, char frame);
void output(const AsciiPicture& asciipicture);
/*Stünden sie im Header, würden sie nicht gefunden*/

int main (){
	void createAsciiPicture();
	return 0;
}

void createAsciiPicture (){

	AsciiPicture myAsciiPicture; //Erzeugt AsciiPicture Objekt
	input (myAsciiPicture); //Übergibt String-Lines dem Objekt
	frame (myAsciiPicture,'+'); //Übergibt Rahmen, Rahmensymbol dem Objekt
	output (myAsciiPicture); //Auslesen und Ausgabe des Objekts
}

//Einlesen des Strings
void input(AsciiPicture& asciipicture){

	std::cout << "Bitte geben Sie ein Asciibild ein :\n";

	std::ifstream ifs;
	std::string text;
	//ifs.open("C:/asci1.txt");
	ifs.open("C:/asci2.txt");
	while(std::getline(ifs,text)){
		asciipicture.add_line(text);//übergibt text an das Objekt		
	}
}

//Fügt dem Objekt ein Rahmen hinzu
void frame (AsciiPicture& asciipicture, char frame){

	//Rahmenerstellung
	const std::string left_border (frame+std::string(" ")); 
	const std::string right_border (std::string(" ")+frame); 

	const AsciiPicture::size_type max = asciipicture.get_column();//Maximale Spaltenbreite

	const std::string full_line(max+4, frame);//4, da 2 Rahmensymbole und 2 Leerzeichen
	const std::string std_line = left_border+std::string(max, ' ')+right_border; 

	//Rahmen hinzufügen
	const AsciiPicture::size_type row = asciipicture.get_row();

	for(AsciiPicture::size_type i = 0; i<row; ++i)
	{
		//Leerräume zwischen Chars und Rand mit Leerzeichen füllen
		AsciiPicture::size_type anz = max-asciipicture.get_line(i).size();//Ermitteln der "Leerräume"

		//Ermittelte Anzahl von Leerzeichen erstellen
		std::string space(anz, ' ');

		asciipicture.get_line(i).insert(0,left_border);
		asciipicture.get_line(i).append(space+right_border); //Leerzeichen hinzufügen
	}

	//Äußere Rahmen hinzufügen
	asciipicture.add_line(full_line, AsciiPicture::size_type(0)); //Oben
	asciipicture.add_line(std_line, AsciiPicture::size_type(1)); //Oben - 1
	asciipicture.add_line(std_line);//Unten - 1
	asciipicture.add_line(full_line);//Unten
}

void output(const AsciiPicture& asciipicture) 
{
	std::cout<<"Ergebnis: "<<std::endl<<std::endl;
	AsciiPicture::const_iter begin= asciipicture.begin();

	//Ausgabe
	while(begin!=asciipicture.end())
	{
		std::cout<<*begin<<std::endl;
		++begin;
	}

	std::cout<<std::endl;
	std::cout<<asciipicture[2]<<std::endl;

}

Vielen Dank schonmal