ich habe in einer Klasse eine Methode und einen Vector angelegt. Diesen Vektor nutze ich in der Methode und zwar schreibe ich in einer Schleife etwas rein mit push_back. Gibt es die Möglichkeit diesen Vektor aus der main() zu nutzen, nachdem man die Methode aufgerufe hat ohne return vector?

Gruß

Ich versuche es mal anhand deines Codes zu beschreiben:

#include <iterator>
#include <vector>
#include <iostream>
#include <algorithm>

class foo_t {

    std::vector< int > bar;

    public:
        void foo() {

            for( int i = 1; i < 10; ++i )
                bar.push_back( i );
        }

        std::vector< int > const & get_bar() const { return bar; }
};

int main() {

// hier hätte ich gerne den vektor "bar" der in meinem Fall ein double ist, aber das tut ja nichts zur Sache. Diesen vektor will ich dann hier sortieren und weiter verarbeiten können...

}

Evtl. schaust Du Dir nochmal Referenzen/Referenzen auf const an.

Vielleicht hilft Dir auch, wenn ich in Swordfishs Klasse noch eine Überladung von get_bar() einfuege.
Allerdings ist Referenzen auf Member rauszugeben nicht "state of the art" - deswegen:
Zeig Code und sag vor allem klar, was Du machen willst.

#include <iterator>
#include <vector>
#include <iostream>
#include <algorithm>

class foo_t {
	std::vector< int > bar;
public:
        void foo() {
        	for( int i = 1; i < 10; ++i )
        		bar.push_back( i );
        }   
        std::vector< int > const & get_bar() const { return bar; } 
        std::vector< int >       & get_bar()       { return bar; }
};

int main() {
	// hier hätte ich gerne den vektor "bar" der in meinem Fall ein double ist, 
	// aber das tut ja nichts zur Sache.
	// Diesen vektor will ich dann hier sortieren und weiter verarbeiten können...
	using namespace std;
	foo_t f;
	f.foo();
	auto& bar = f.get_bar();
	sort(begin(bar), end(bar));
}

ich habe in einer Klasse eine Methode und einen Vector angelegt. Diesen Vektor nutze ich in der Methode [...] Gibt es die Möglichkeit diesen Vektor aus der main() zu nutzen, nachdem man die Methode aufgerufe hat ohne return vector?

Ja. Du kannst den Vektor natürlich im public-Abschnitt der Klasse definieren, dass da jeder drauf zugreifen kann. Aber irgendwie habe ich ein bisschen das Gefühl, dass du aus etwas, was eine Funktion sein sollte, eine Klasse gebaut hast.

ich versuche mal anhand von Beispielen zu erklären, was ich meine

Als erstes habe ich meine Klasse Praser:

class Parser {	
public:
	void MainParser(string daten);
	vector<double> x;
	vector<char> y;
private:
	bool h;
	int c1;

};

In der Methode MainPraser nehme ich einen String, welcher durch ein cin eingelesen wird auseinander und schreibe einzelne Werte in den Vector x und andere Werte in den Vector y (einmal Zahlen und das andere mal Zeichen) mit z.B. p.x.pushback(wert);

Wenn ich innerhalb der Methode auf den Vector x oder y zugreifen will, klappt das wunderbar. Will ich aber in der main(), nachdem ich die Methode mit

String t1 = "Hallo 654"; // Hier will ich z.b. alle Zahlen in den Vektor x und Zeichen in den Vector y
Parser p;
p.MainParser(t1);

aufgerufen habe, auf den vector x oder y zugreifen, bekomme ich einen Compiler Fehler.
Kann es sein, dass wenn ich Daten in einen Vector innerhalb einer Schleife schreibe, dass diese Daten dann nur innerhalb der Schleife im Vector enthalten sind?

Gruß

Habs die Stellen, wo ich den Vector ausgeben kann kommentiert. In der gesamten Funktion nutze ich nur die Funktion push_back() um etwas in den Vektor zu schreiben. Ansonsten wird der Vektor nicht genutzt.

#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#include <iterator>
#include <algorithm>

using namespace std;

#define PI 3.14159265

class Parser {	
public:
	string checkWhitespaces(string whitespaces);	// Methode wird angelegt - Whitespace löschen
	bool checkZahl(char wert);						//						 - Auf Zahl prüfen
	double MainParser(string daten);
	vector<double> Zahlen;
	vector<char> Zeichen;

private:
	bool h;
	int c1;

};

void Parser::MainParser(string t1) {

	Parser p; // Klasse wird zugewiesen
	Verarbeiten v;

	for(int i = 0; i < t1.length(); i++) {

		switch(t1[i]) {

// ...

p.Zahlen.push_back(trigo_berechnen);

// ...

		} // Switch Ende

	} // for-Schleife Ende

// Hier kann ich beide Vectoren ausgeben
//

} // MainPraiser Ende

int main() {

	Parser p; 
	Verarbeiten v;

	string t1;
	t1 = "asgb 84515";

	p.MainParser(t1);

// Hier bekomme ich keine Ausgabe...
	bool z = true;
	int xy = 0;
	do {

	if(p.Zahlen.size() > xy) {
	cout << "Der " << xy << ". Vektor: " << p.Zahlen[xy] << endl;
	xy++;
	}
	else {
		z = false;
	}

	} while(z);
return(0);
} // main() Ende

EDIT:

do { 

    if(p.Zahlen.size() > xy) { 
    cout << "Der " << xy << ". Vektor: " << p.Zahlen[xy] << endl; 
    xy++; 
    } 
    else { 
        z = false; 
    } 

    } while(z);

Dieses Konstrukt ist auch mehr als Mysteriös.
Letztendlich würde eine for Schleife reichen:

for (int xy = 0; xy < p.Zahlen.size(); ++xy)
    cout << "Der " << xy << ". Vektor: " << p.Zahlen[xy] << endl;

Mit der Schleife hast du wohl recht, aber man will ja noch was lernen Danke für den Tipp!

Wenn ich Parser p; aus der Methode nehme, bekomm ich einen Compiler Fehler.

Dann hast du da wohl noch mehr Fehler.

Wenn ich Parser p; aus der Methode nehme, bekomm ich einen Compiler Fehler.

Du willst doch sicher auf dem aktuellen Objekt arbeiten. Also

p.Zahlen.push_back(trigo_berechnen);

Zahlen.push_back(trigo_berechnen);

Bitte noch einmal angucken, was es mit Memberfunktionen auf sich hat und wie sie genau funktionieren.

Jo, habs. Es klappt! Besten Dank!

Aber wichtig: Verstehst du den Unterschied? Was deine Variante bedeutete und was bei der Korrektur anders ist?

Das sind ganz wichtige Themen, wenn da bei dir noch Restzweifel bestehen, dann ist ein Blick ins Lehrbuch angesagt (-> zweiter und vierter Link in meiner Signatur).

Danke!

hätte da noch eine weitere Frage zum ähnichen Thema.

Wenn ich zu meiner Klasse Parser noch eine Variable i hinzufüge:

class Parser {	
public:
	string checkWhitespaces(string whitespaces);	// Methode wird angelegt - Whitespace löschen
	bool checkZahl(char wert);						//						 - Auf Zahl prüfen
	double MainParser(string daten);
	vector<double> Zahlen;
	vector<char> Zeichen;
int i;
private:
	bool h;
	int c1;

};

class Verarbeiten : public Parser {
public:
	double zusammenfassen(string t1);

private:
};

und dann eine Methode in der Klasse Verarbeiten anlege, welche von Parser erbt. Wie kann ich dann in einer Methode von Parser in der die Variable i hochgezählt wird, in einer Methode von Verarbeiten weiter hoch zählen?

Sprich:

void Verarbeiten::zusammenfassen(...) {
...
i++; // <<-- Dieses i will ich von weiter hochzählen
...
}

void Parser::MainParser(...) {
//..
 i++;

...

zusammenfassen(...);

// Hier sollte i dann entsprechend einen höheren Wert habe, wenn die Funktion zusammenfassung() i hochgezählt hat.
//...
}

Hier mal mein Code:

#include <iostream>
#include <math.h>
#include <string>
#include <vector>
#include <iterator>
#include <algorithm>

using namespace std;

#define PI 3.14159265

class Parser {	
public:
	string checkWhitespaces(string whitespaces);	// Methode wird angelegt - Whitespace löschen
	bool checkZahl(char wert);						//						 - Auf Zahl prüfen
	void MainParser(string &daten);
	vector<double> Zahlen;
	vector<char> Rechenzeichen;
	int i;

private:
	bool h;
	int c1;

};

class Verarbeiten : public Parser {
public:
	double punkt_vor_strich(vector<double> &Z, vector<char> &RZ);
	double erg_berechnen(vector<double> &Z);
	double trigo_berechnen(string t1);

private:
};

void Parser::MainParser(string &t1) {

	int temp = 0;
	int c2 = 0;
	h = true;
	c1 = 0;	

	for(i = 0; i < t1.length(); i++) {

		switch(t1[i]) {
		//...
		i++;

		//...
	   		// wenn hier i = 5 ist, i auch nach der Funktion 5
			Zahlen.push_back(v.trigo_berechnen(t1)); // Innerhalb der Funktion ist i = -85xxxxxxx	
		//...
		} // Switch Ende

	} // for-Schleife Ende

} // MainPraiser Ende

double Verarbeiten::trigo_berechnen(string t1) {

i++;

return trigo_berechnen2;
}

Das ist v von Verarbeiten. Wenn ich das nicht tue, sagt er mir, es wäre nicht deklariert ...

v.trigo_berechnen(t1)

Das ist v von Verarbeiten. Wenn ich das nicht tue, sagt er mir, es wäre nicht deklariert ...

Das ist wieder das gleiche wie vorher mit dem p. Du legst wild und ohne Plan Objekte an, weil der Compiler meckert, ohne zu verstehen, warum er meckert. Das v hat mit deinem aktuellen Objekt nichts zu tun.

Dein Design ist wirklich sehr komisch.