EDIT: Fehler gefunden Falscher Operator benutzt... Anstatt "." muss man "->" benutzen, da f ja ein Pointer ist Beitrag kann gelöscht werden

Hier habe ich eine EraseSharp.h:

#include <fstream>
#include <iostream>
#include <vector>
#include <string>

class EraseSharp
{
private:
	std::fstream *f;
	std::vector<std::string> lines;

public:
	EraseSharp(std::fstream stream);
	~EraseSharp();
	bool GetLines(std::string path);
};

und die dazugehörige EraseSharp.cpp:

#include "EraseSharp.h"

EraseSharp::EraseSharp(std::fstream stream)
:	f(&stream)
{
}

EraseSharp::~EraseSharp()
{
	f.close(); //Hier ist ein Fehler
}

bool EraseSharp::GetLines(std::string path)
{
	if(f != NULL)
	{
		f.open(path.c_str(), std::ios_base::in | std::ios_base::out); //Hier ist ein Fehler
	}
	return 1;
}

Jetzt bekomme ich zwei Fehler. Ich habe im Quelltext markiert, wo sie sich befinden.
Die Fehler:

Fehler	1	error C2228: Links von ".close" muss sich eine Klasse/Struktur/Union befinden.

Fehler	2	error C2228: Links von ".open" muss sich eine Klasse/Struktur/Union befinden.

Ich denke es ist einfach nur ein Verständnisproblem, was ich mit Klassen habe
Und der Sinn des Quelltextes sollte eigentlich keine Rolle spielen

Gruß Speedy_92

EDIT: Fehler gefunden Falscher Operator benutzt... Anstatt "." muss man "->" benutzen, da f ja ein Pointer ist Beitrag kann gelöscht werden

Gelöscht wird hier so schnell nichts, ganz davon abgesehen habe ich eh noch Anmerkungen an dich:

1. Willst du wirklich ständig den stream und strings kopieren?

// 1.      Call by Value (Kopie)
EraseSharp(std::fstream stream);
// 2.      Call by Referenz
EraseSharp(std::fstream & stream);
// 3.      Call by const Referenz
EraseSharp(std::fstream const & stream);

Fall 1: Dies ist der Fall wie du einen Aufruf machst. Dies wird auch Call-By-Value genannt, und es wird der ursprüngliche Wert in eine neue Variable kopiert. Dies ist bei den Standardtypen wie int, long oder Zeigern in Ordnung, nicht aber bei Objekten.

Fall 2: Hierbei wird keine Kopie angelegt, sondern mit einer Referenz gearbeitet (Referenz = Aliasnamen einer bestehenden Variable). Eine Änderung an dieser Referenz wirkt sich auf die ursprüngliche Variable aus. Dies wird sowohl bei den Standardtypen wie auch Objekten verwendet wenn eine Änderung erwünscht ist (Bei dir eher nicht der Fall).

Fall 3: Dies sollte der Standard für Objektübergaben sein. Es wird auch hier mit einer Referenz gearbeitet, aber die direkte Änderung ist nicht möglich.

2. (Seltener Relevant, aber zur Ergänzung) Gegebenenfalls kann auch eine Referenz statt einen Zeiger Sinn machen sofern der Stream immer gesetzt sein muss, und das Objekt weder Kopier noch zuweisbar sein soll.

cu André

Vielen Dank. Ich habe den Code ein wenig abgeändert und erweitert.
Nja. Jetzt habe ich aber ein anderes Problem :
RemoveSharp.h

#include <fstream>
#include <iostream>
#include <vector>
#include <string>

class RemoveSharp
{
private:
	std::fstream f;
	std::vector<std::string> lines;
	std::string path;
	std::string content;

public:
	RemoveSharp();
	~RemoveSharp();
	bool LoadRecource(std::string path);
	void RemoveSharpLines();
	void SaveResource();
	void ToUpper();
};

RemoveSharp.cpp

#include "RemoveSharp.h"

RemoveSharp::RemoveSharp()
{
    path = "";
    content = "";
}

RemoveSharp::~RemoveSharp()
{
	if(f.is_open())
		f.close();
}

bool RemoveSharp::LoadRecource(std::string path)
{
		this->path = path;
		f.open(this->path.c_str(), std::ios_base::in | std::ios_base::out);
		std::string temp;
		while(std::getline(std::cin, temp))
		{
			lines.push_back(temp);
		}
		return 1;
	}
	return 0;

void RemoveSharp::RemoveSharpLines()
{
	for(std::vector<std::string>::iterator iter = lines.begin(); iter != lines.end(); iter++)
	{
		if((*iter)[1] == '#')
			lines.erase(iter);
	}

	for(unsigned int i = 0; i < lines.size(); i++)
	{
		content += lines[i] + "\n";
	}
}

void RemoveSharp::SaveResource()
{
	f.write(content.c_str(), content.size());
}

void RemoveSharp::ToUpper()
{
	for(unsigned int i = 0; i < lines.size(); i++)
	{
		std::string temp = lines[i];
		for(unsigned int j = 0; j < temp.size(); j++)
		{
			if(islower(temp[j]))
				toupper(temp[j]);
		}
	}
}

main.cpp

#include "RemoveSharp.h"
#include <fstream>
#include <iostream>

int main()
{
	std::fstream f;
	RemoveSharp rs;
	rs.LoadResource("C:\\Florian\\Projekte\\C++ in Visual Studio\\C++ Primer\\EraseSharp\\Debug\\gcc.mak");

	return 0;
}

1. Meine Intellisense (Visual Studio) findet, wenn ich "rs." eingeben nur irgendwelchen Schrott:
Die private Variable f, den privaten vector lines, eine Methode RemoveSharps, eine Methode SetLines und den Destruktor...
Dies sollte überhaupt nicht so sein, denn z.B. die Methode SetLines gibt es noch nicht mal mehr
2. Wenn ich mal einfach die Intellisense ignoriere und wie oben

rs.LoadResource("C:\\Florian\\Projekte\\C++ in Visual Studio\\C++ Primer\\EraseSharp\\Debug\\gcc.mak");

aufrufe bekomm ich einen Error:

Fehler	1	error C2039: 'LoadResource': Ist kein Element von 'RemoveSharp'

Dies kann aber eigentlich nicht sein, da die Methode in RemoveSharp.h deklariert und RemoveSharp.cpp implementiert ist

Gruß Speedy_92

...Intellisense das ärgert mich...

Unter Umständen funktioniert die Aktualisierung nicht, ggf. hilft ein "Rebuild All" ansonsten manuell aus dem Projektverzeichnis die, ich glaube *.nsb oder so ählich - Datei löschen, und anschließend nochmal neu linken.

In dem Fall fehlt aber wohl einfach eine Schließende } hinter der Methode "LoadRessource", bzw. ein return 0 zuviel. Immer sauber einrücken dann sieht man dies auch.

Zu deinem Code, Ich würde dennoch Objekte mit const Referenz übergeben:

bool RemoveSharp::LoadRecource(std::string & const path) // <-- Keine unnötige Kopie
{
  this->path = path;
  f.open(this->path.c_str(), std::ios_base::in | std::ios_base::out);
  std::string temp;
  while(std::getline(std::cin, temp))
  {
     lines.push_back(temp);
  }
  return 1;
  // }          <-- Auskommentiert: Copy-Paste-Fehler?
  // return 0;  <-- Auskommentiert: Copy-Paste-Fehler?
} //            <-- Hinzugefügt

Des weiteren:

void RemoveSharp::RemoveSharpLines()
{
  // 1. Du hast in deiner Version pro Schleifendurchlauf einmal lines.end()
  //    aufgerufen, was unnötig ist
  // 2. Besster ++iter als iter++ (ggf. ein temporärer Wert pro Durchgang
  //    weniger
  for(std::vector<std::string>::iterator iter = lines.begin(), end = lines.end();
    iter != end; ++iter)
  // ...
  // Hier ebenso:
  for(unsigned int i = 0, size = lines.size(); i < size; ++i)
  // ...

cu André

while(std::getline(std::cin, temp))

Der Debugger lässt sich nicht weiterschieben und der Fokus geht auf die Console über, wo sich leider nichts tut. Ich kann auch nicht weiterdebuggen...
Aber die Datei existiert. Ich weiß leider nicht wo mein Fehler steckt.

PS: Das mit der nbs-Datei hat super funktioniert

Gruß Speedy_92

Vielen Dank. Ich habe es geändert. Aber das mit der Klammer "}" scheint ein copy-paste Fehler gewesen zu sein...
Ich habe leider ein Inhaltliches Problem.
Ich habe den Code gedebuggt und an dieser Stelle bleibt er im Code einfach stehen (RemoveSharp.cpp ->LoadResource):

while(std::getline(std::cin, temp))

Der Debugger lässt sich nicht weiterschieben und der Fokus geht auf die Console über, wo sich leider nichts tut. Ich kann auch nicht weiterdebuggen...
Aber die Datei existiert. Ich weiß leider nicht wo mein Fehler steckt.

PS: Das mit der nbs-Datei hat super funktioniert

Gruß Speedy_92

Du willst doch von deinem File lesen, oder?

Dann sollte das

while(std::getline(std::cin, temp))

so heißen

while(std::getline(f, temp))

Gruß
Tobi

std::getline(std::cin, bla)

erklärt wurde...
Aber trotzdem danke

lines.erase(iter);

in void RemoveSharp::RemoveSharpLines() in der RemoveSharp.cpp.
Aber in dem vector lines sind alle Zeilen richtig reingeladen worden...

Folgendes Problem (Kann man hier keine Bilder einfügen?, dann halt der externe Link):klick me

Tut mir leid, wenn ich nerve
Aber ich habe jetzt ein Runtime Problem. Es tritt an dieser Stelle auf:

ahh, ganz übersehener Anfängerfehler:
Du kannst nicht ohne weiteres innerhalb einer Schleife über eine Liste iterieren und Einträge löschen. Den jedes hinzufügen und löschen kann den Interator ungültig machen! (Dies ist dein Problem).

Um es verständlicher zu machen, ein Beispiel am Vector. Ein Vector ist ein zusammenhängender Speicherbereich:

Iteratorposition
                              |
Vectorinterner Zeiger ---> [1|2|3|4|5]

Bei jedem Löschen oder Einfügen kann der Speicherbereich des Vektors geändert werden (An eine andere Adresse kopiert und angepasst), zudem ist nicht ganz klar wohin nach einem Löschen - selbst wenn der Speicherbereich identisch bleiben würde - der Iterator zeigen sollte.

cu André

bool startsWithSharp(const std::string& str)
{
   return str[1] == '#';
}

void RemoveSharp::RemoveSharpLines()
{
    lines.erase(std::remove_if(lines.begin(), lines.end(), startsWithSharp));
    ///...
}

(Soll eigentlich wirklich das zweite Zeichen auf '#' überprüft werden ?
Das erste Zeichen wäre 'str[0]' !)

Siehe auch "Effective STL" von Scott Meyers

"RemoveSharp::startsWithSharp": Dem Funktionsaufruf fehlt die Argumentliste. Verwenden Sie "&RemoveSharp::startsWithSharp", um einen Zeiger auf den Member zu erstellen.

Weil ich wüsste auch ehrlich gesagt nicht, was ich bei startsWithSharp als Parameter angeben muss, weil ich kann ja lines nicht durchiterieren...

Hier auch mit einem Beispiel:

http://www.cplusplus.com/reference/algorithm/remove_if.html

Für Funktionsobjekt google mal nach Funktor/Funktionsobjekt.

Funktionsobjekte sind Objekte, deren Klasse den Operator () überlädt. Nachfolgend ist ein Beispiel für einen solchen Functor aufgeführt. Er soll dazu dienen, die Werte der Elemente in einem Container zu begrenzen.

Allerdings sehe ich in dem remove_if-Beispiel nichts von Operatorüberladung... oder bin ich etwa blind?

In dem Wikipedia-Artikel wird die Operator-Überladung wiederum bestätigt:

Bei Funktionsobjekten oder Funktoren handelt es sich um Objekte, die genauso aufgerufen werden können wie Funktionen. Bei ihnen ist der Funktionsoperator () mit der Operatorfunktion „operator()“ überladen. Es sind Objekte, die sich wie Funktionen verhalten, aber trotzdem alle Eigenschaften von Objekten haben. Bei den Funktionsobjekten gibt es folgende Kategorien:

    * Generatoren ohne Funktionsparameter „f()“
    * Unäre Funktionen mit einem Funktionsparameter „f(x)“
    * Binäre Funktionen mit zwei Funktionsparametern „f(x,y)“

Deswegen habe ich es noch nicht verstanden, da die beiden Beispiele unterschiedlich sind und (für mich) keine Gemeinsamkeiten in Sachen Functor haben.

Speedy_92 schrieb:

Allerdings sehe ich in dem remove_if-Beispiel nichts von Operatorüberladung...

Da wird auch kein Funktor eingesetzt, sondern ein(e) (Zeiger auf eine) globale Funktion, die/der ebenfalls als Argument für remove_if verwendet werden darf. Also stimmt schon, was drakon geschrieben hat:

drakon schrieb:

Ein Funktionsobjekt, oder eine Funktion.

MfG,

Probe-Nutzer

std::vector<int> my_vec;

my_vec.push_back(1);
my_vec.push_back(2);
my_vec.push_back(3);
my_vec.push_back(4);
my_vec.push_back(5);

std::vector<int>::iterator iter = my_vec.begin();
while(iter != my_vec.end())
{
    if((*iter) == 4)
        iter = my_vec.erase(iter);
    else
        iter++;
}

Weil erase einen Iterator auf das nachfolgende Element angibt.

Hallo,
ich habe gerade ein wenig im Forum gestöbert und eine viel einfachere Methode gefunden, um ein Element aus einem std::vector zu löschen. Hier ein kleines

Ja. Das wird so auch viel gemacht, jedeoch ist das nicht sehr elegant. Die Methode über Funktionsobjekte/Funktionen ist dem eigentlich zu bevorzugen, aber schlussendlich deine Entscheidung.

Speedy_92 schrieb:

Hallo,
ich habe gerade ein wenig im Forum gestöbert und eine viel einfachere Methode gefunden, um ein Element aus einem std::vector zu löschen. Hier ein kleines

Ja. Das wird so auch viel gemacht, jedeoch ist das nicht sehr elegant. Die Methode über Funktionsobjekte/Funktionen ist dem eigentlich zu bevorzugen, aber schlussendlich deine Entscheidung.

Es ist nicht nur nicht elegant, es ist auch ineffizient. Da die Komplexität eines einzelnen erase jeweils linear bzgl. der Distanz zum Ende des vectors ist, hat man im schlimmsten Fall eine quadratische Komplexität für den gesamten Vorgang. remove_if und das folgende erase haben aber jeweils nur lineare Komplexität.