ich habe mal wieder ein Problem mit meinen Klassen

und zwar will ich als Parameter einer Klasse struct ein vector-Feld anlegen um Zahlen zu speichern.

folgendes hatte ich mir überlegt:

struct sondenfeld {
	int sondenanzahl;

	vector <int> x_koordinaten();   
	vector <int> y_koordinaten();	 

        //Setter
	void set_X_coor(int i, int x){
		x_koordinaten[i] = x;
	};
	void set_Y_coor(int i, int y){
		y_koordinaten[i] = y;
	};

	// GETTER

	double get_X_coor_sonde(int i){
		return x_koordinaten[i] ;
	};
	double get_Y_coor_sonde(int i){
		return y_koordinaten[i] ;
	};

       // Init
	void initialisieren(int anzahl){
		sondenanzahl = anzahl;

		while (anzahl >= 0){
			x_koordinaten.push_back(1);
			y_koordinaten.push_back(1);
			--anzahl;
		}
	};

        // size
	int get_size_X(){
		return x_koordinaten.size();
	};

das funktioniert aber so irgendwie nicht --> Fehlermeldung:
"sondenfeld::x_koordinaten": Dem Funktionsaufruf fehlt die Argumentliste. Verwenden Sie "&sondenfeld::x_koordinaten", um einen Zeiger auf den Member zu erstellen...

Habt ihr da ne Lösung?

mach mal die Klammern weg:

vector <int> x_koordinaten;  
    vector <int> y_koordinaten;

Etwas eleganter.

Wäre es nicht auch sinnvoll ein struct zu schreiben das x und y beinhaltet und dann nur einen vector zu nehmen? sondenanzahl kannst auch durch koordinaten.size() dann ersetzen.

Funktioniert alles wunderprächtig

vector <int> x_koordinaten();   
	vector <int> y_koordinaten();

wenn ich sowas sehe, dann fühle ich mich immer genötigt zu antworten.
Eine X-Koordinate (hier einer Sonde) gehört mehr zu der Y-Koordinate der identische Sonde als zu einer X-Koordinate irgendeiner anderen Sonde. D.h. es fehlt ein Typ der X- und Y-Koordinate zusammenfasst und erst danach sollte man dies in einem Container organisieren.

Ich habe mir erlaubt Deinen Code in diesem Sinne zu kommentieren:

struct Koordinate //# fasse x und y zu 'Koordinate' zusammen
{
    Koordinate() : m_x(1), m_y(1) {}
    Koordinate( int x, int y ) : m_x( x ), m_y( y ) {}
    int m_x, m_y;  // oder double !?
};

struct sondenfeld {
    std::vector <Koordinate> koordinaten;  //# std::.., da im Header-File

    //Setter ??                                //# wozu Setter? -> Design?
    void set_coor(int i, const Koordinate& xy ){
        koordinaten[i] = xy;
    };
    // GETTER   
    Koordinate get_coor_sonde(int i) const { //# const bei get_*
        return koordinaten[i];
    };

    //# Init geschieht im Konstruktor
    explicit sondenfeld( int anzahl )
        : koordinaten( anzahl, Koordinate(1,1) )
    {}

    // size
    int get_size() const {
        return koordinaten.size();
    }
};

Der Unterschied ist ein klassisches Beispiel zwischen prozeduraler und objektorientierter Programmierung.

Gruß
Werner