Ich bin derzeit dabei ein Tool zu schreiben das mit Werte aus einer CSV Datei ausliest und diese in eine MySql db wieder einspielt.

Mein Problem ist jetzt folgendes:

Ich habe einen "CSV Reader" geschrieben dir mit die Werte ausließt.

Soweit so gut, nur möchte ich diese Werte nicht in dieser Funktion weiter verarbeiten sondern dem Hauptprogramm zurückgeben um dann in einer neuen Funktion diese Daten zu verarbeiten.

Das Problem selber ist sicher für euch kein Problem zu lösen, nur möchte ich eine Lösung die für mich als Anfänger leicht zu verstehen ist.(wenn möglich)

Ich weis das es mit Vectoren gehen soll Dynamische arrays zu erzeugen, nur hab ich Vektoren noch nicht durchgekommen und hab d.h. auch keine Ahnung wie und warum das Funktioniert.

Was ich gern hätte währe ein schubs in die richtige Richtung.

Hier mal meine Reader Funktion:

bool readFile (string fileIn){

	fstream file;
	file.open ((fileIn).c_str(),ios::in);
	if (file.fail())
	{
		cout << "Error beim oeffnen der datei: " << (fileIn).c_str() << endl;
		perror("Read Fehler");
		return false;
	}

	string tmp;
	while(!file.eof() ) {
	getline(file, tmp); // Zeile lesen

	size_t x=0;
	size_t p=0;
	int i=0;
	string auftrag[13];

	// ; suchen und Werte trennen
	while(x=tmp.find(';',x)){
		if (x==string::npos){
			break;
		}

		auftrag[i] = tmp.substr(p, (x-p));

	//	cout << "found : " << auftrag[i] << endl;
		i++;
		x++;
		p=x;		
	}

	// Hier sollten dann irgendwie am ende ein dynamisches array sein.

}

	file.close();
	return true;
}

Der Code ist sicher nicht so Optimal geschrieben, er funktioniert jedoch

Aufgebaut sollte das Array so sein: auftrag[zeilennr.][spaltennr.]
Mein Problem genau ist jetzt nicht zu wissen wie viele Zeilen die Datei hat, ich könnte natürlich die Datei zwei mal einlesen um zu erfahren wie viele Zeilen da sind, nur finde ich diese Lösung eher "Unschön".

Auch bin ich der Meinung wenn ich Speicher aus dem heap mit new aus der Funktion heraus anfordere, wird dieser Speicher doch automatisch nach Beendigung der Funktion wieder freigegeben oder?
Dann müsst ich das array schon in der Main Funktion anlegen.

Danke.

Lies dich lieber in std::vector ein. Z.Bsp. hier im Magazin
http://www.c-plusplus.net/forum/viewtopic-var-t-is-143816.html
Damit hast du es wesentlich leichter.

iPanic schrieb:

Auch bin ich der Meinung wenn ich Speicher aus dem heap mit new aus der Funktion heraus anfordere, wird dieser Speicher doch automatisch nach Beendigung der Funktion wieder freigegeben oder?

Nein. Was du mit new anforderst musst du auch selber wieder freigeben.

Nun hänge ich jedoch bei der Rückgabe des vectors an die main Funktion.

Ich hätte gern den Vector als Zeiger, nur sind alle meine Versuche einen zeiger mit

vector<string> *vec;

zu erzeugen fehlgeschlagen.

Wenn mir wer nen tipp geben könnte.

Hier mal die reader funktion mit vectoren:

bool readFile (string fileIn){

	fstream file;
	file.open ((fileIn).c_str(),ios::in);
	if (file.fail())
	{
		cout << "Error beim oeffnen der datei: " << (fileIn).c_str() << endl;
		perror("Read error");
		return false;
	}

	// Mehrdimensionales array erstellen
	vector<vector<string> > vAuftrag;	
	vAuftrag.reserve(100);

	string tmp;
	while(!file.eof() ) {

		vector <string> spalten; // Kann ich diesen vector einfach immer neu erstellen oder muss man den auch wieder löschen?

		getline(file, tmp); // Zeile lesen

		size_t x=0;
		size_t p=0;
		int i=0;
		string auftrag[13];
		// ; suchen und Werte trennen
		while(x=tmp.find(';',x)){
			if (x==string::npos){
				break;
			}

			//Daten in die zweite ebene schreiben
			spalten.push_back(tmp.substr(p, (x-p)));

			i++;
			x++;
			p=x;		
	}
	//Daten in die erste ebene schreiben
	vAuftrag.push_back(spalten);

}

system("PAUSE");

file.close();
return true;
}

Danke.

iPanic schrieb:

Ich hätte gern den Vector als Zeiger...

Mach dir das Leben nicht schwerer als es ist. Kopien können wenn sie häufig gemacht werden zwar teuer sein, aber optimiere niemals wenn du nicht weißt das es ein Problem darstellt...

Die üblichen Varianten:

// Intuitiv, aber ggf. (keine Ahnung wie gut Compiler wegoptimieren) mit einer Kopie:
std::vector<std::string> GetStringVector()
{
    std::vector<std::string> result;
    result.push_back("a");
    result.push_back("b");
    return result;
}

// Weniger intuitiv, aber ohne Kopie (wobei ich das intuitiv meist mehr betrachte
// solange es ein Programm nicht merklich verlangsamt)
void GetStringVector(std::vector<std::string> & result)
{
    result.push_back("a");
    result.push_back("b");
}

// Verwendung
int main()
{
    // Variante 1:
    std::vector<std::string> v1 = GetStringVector();

    // Variante 1:
    std::vector<std::string> v2;
    GetStringVector(v2);
}

void editStringVector(std::vector<std::string> & result)
{
    result.push_back("a");
    result.push_back("b");
}

Oder fillStringVector wäre auch möglich.

Funktionen so benennen, wie sie sich verhalten.

Unleserlich.