Hätte eine Frage zum operator() des STL vectors:
Ich wollte diesen operator überladen, aber anscheinend gibt es ihn noch garnicht !

Kann man ihn deshalb neu definieren ?

Also im Vergleich zum [] operator möchte ich einfach noch einige Abfragen innerhalb des () operators anstellen.

Danke für eure Antworten !

Gruß,
GiantGeorge

grüße

mein Ziel ist es einfach auf die normale Weise mit [] weiterhin zugreifen zu können und zusätzlich, dass ich auf meine Weise noch irgendwie anders zugreifen kann, eben z.B. über operator().

Was spricht denn dagegen den operator() zu überladen ? V.a. hab ich nach wie vor das Problem, dass es diesen operator() für Vektoren garnicht zu geben scheint. Muss zugeben, dass ich nicht so beflissen bin in dieser Geschichte, aber über

int std::vector< int > ::operator ()(int i, int j);

sollte man doch eigentlich diesen operator() definieren können ?!

Was wäre denn eine Alternative ?

Gruß,
GiantGeorge

The function-call operator, invoked using parentheses, is a binary operator.

primary-expression ( expression-listopt )
In this context, primary-expression is the first operand, and expression-list, a possibly empty list of arguments, is the second operand. The function-call operator is used for operations that require a number of parameters. This works because expression-list is a list instead of a single operand. The function-call operator must be a nonstatic member function.

The function-call operator, when overloaded, does not modify how functions are called; rather, it modifies how the operator is to be interpreted when applied to objects of a given class type. For example, the following code would usually be meaningless:

Point pt;
pt( 3, 2 );
Given an appropriate overloaded function-call operator, however, this syntax can be used to offset the x coordinate 3 units and the y coordinate 2 units. The following code shows such a definition:

// function_call.cpp
class Point
{
public:
Point() { _x = _y = 0; }
Point &operator()( int dx, int dy )
{ _x += dx; _y += dy; return *this; }
private:
int _x, _y;
};

int main()
{
Point pt;
pt( 3, 2 );
}
Note that the function-call operator is applied to the name of an object, not the name of a function.

Wenns dir darum geht, das SO nutzen zu können, kannst du es ja versuchen. Ich wäre damit allerdings vorsichtig. Im Zweifelsfall solltest du (wie es die STL mit "at()" ja vormacht) einen kurzen, sprechenden Funktionsnamen verwenden und operator() in Ruhe lassen.

also mir leuchtet irgendwie nicht so recht ein, was das Beispiel Point hier mit der Klasse Vector zu tun hat.
Innerhalb der Klasse Point wird hier ja doch operator() definiert!
Aber ich kann ja schlecht in der Klasse Vector rumfummeln, sondern hab eben versucht von außen mir diesen operator() zu definieren/überladen.

Was ist denn konkret falsch, wenn ich in meiner
test.hpp
das hier schreib:

inline int std::vector< int >::operator()(int i, int j){
	return i*j;
}

Mein VS Compiler meint jedenfalls nur

'()': Ist kein Element von 'std::vector<_Ty>'
1> with
1> [
1> _Ty=int
1> ]

Aber ich will mir diesen operator ja doch neu definieren!

Dankeschön

GiantGeorge

grüße

inline int std::vector< int >::operator()(int i, int j){
    return i*j;
}

Was kann ich denn überhaupt konkret machen, ohne abzuleiten ?
Am liebsten Code, weil ich grad noch dermaßen ohne Plan bin.

Also schon mal Danke!

PS: Und Ableitung ist afaik die einzige Möglichkeit, einer vector-Abart eine neue Methode zu spendieren.

PPS: Was soll dieser operator eigentlich im Endeffekt bewirken? So ein "return i*j;" hat imho nichts in der Containerklasse zu suchen.

PS: Und Ableitung ist afaik die einzige Möglichkeit, einer vector-Abart eine neue Methode zu spendieren.

ohne virtuellen dtor wär das ziemlicher müll, ausser man leitet private ab. aber dann könnte man genausogut vector als member nehmen.

Der Code schaut prinzipiell dann folgendermaßen aus:

class Grid{
    public:
		std::vector< cell > cellVec;

		//Access operator
		inline cell std::vector< cell >::operator()( int i, int j, int k );

		void accessCells();

    private:

		//Number of Cells in x, y and z-direction
        const int nx;
        const int ny;
        const int nz;		

		inline vector Grid::operator()( uint i, uint j, uint k )
		{
			//Treatment of the periodic boundary condtions
			if( k < 0 ) k += nz;
			else if( k >= nz ) k -= nz;
			if( j < 0 ) j += ny;
			else if( j >= ny ) j -= ny;
			if( i < 0 ) i += nx;
			else if( i >= nx ) i -= nx;

                  // cellVec is 1-dim 
			return cellVec[i+(j+k*ny)*nx];
		}		
};

void Grid::accessCells()
{
	for(uint k=0; k<nz; ++k){
        for(uint j=0; j<ny; ++j){
            for(uint i=0; i<nx; ++i){
				// access somehow on neighbor cells
				cellVec(i,j-1,k).F = cellVec(i,j,k).F;
			}
		}
	}
}

Spricht wirklich so viel gegen Ableitung ?
Im moment würde ich nämlich gerne wie CStoll sagt, dieser vector-Abart eine neue Methode spendieren.

Lieben Gruß,
GiantGeorge

cell Grid::operator()( uint i, uint j, uint k ) const
{...

Das inline ist hier unnötig. Die Klasse (oder struct) cell muß natürlich kopierbar sein. Man könnte hier auch ein const cell& zurückgeben. Wenn du in diesen Vector schreiben willst brauchst du halt noch eine Funktion, die eine Referenz auf ein vector-Element zurückgibt.

Gruß,
GiantGeorge