Was bedeutet ‚const‘ in Bediener tun () Überlastung?

Question

Ich habe eine Code-Basis, bei dem für die Matrix-Klasse, diese beiden Definitionen sind für () Betreiber:

template <class T> T& Matrix<T>::operator() (unsigned row, unsigned col)
{
    ......
}


template <class T> T Matrix<T>::operator() (unsigned row, unsigned col) const
{
    ......
}

Eine Sache, ich verstehe, ist, dass der zweite nicht den Verweis zurückgibt, aber was tut const Mittel in der zweiten Erklärung? Auch die Funktion wird aufgerufen, wenn ich sage, mat(i,j) tun?

Answer 1

Welche Funktion aufgerufen wird, hängt davon ab, ob die Instanz const ist oder nicht. Die erste Version ermöglicht es Ihnen, die Instanz zu ändern:

 Matrix<int> matrix;
 matrix(0, 0) = 10;

Die const Überlastung ermöglicht Lesezugriff, wenn Sie eine const-Instanz (Referenz) der Matrix haben:

 void foo(const Matrix<int>& m)
 {
     int i = m(0, 0);
     //...
     //m(1, 2) = 4; //won't compile
 }

Die zweite keine Referenz zurückkehren, da die Absicht, nicht zuzulassen ist modifiziert das Objekt (eine Kopie des Wertes erhalten und deshalb nicht die Matrix-Instanz ändern können).

Hier ist T soll ein einfacher numerischer Typ sein, das ist billig (er) nach Wert zurückzukehren. Wenn T auch eine komplexere benutzerdefinierten Typ sein könnte, wäre es auch üblich sein für const Überlastungen eine konstante Referenz zurück:

 template <class T>
 class MyContainer
 {
      //..,
      T& operator[](size_t);
      const T& operator[](size_t) const;
 }

Answer 2

Die const-Version wird auf const Matrices bezeichnet werden. Auf Nicht-const-Matrizen die nicht konstante Version aufgerufen werden.

Matrix<int> M;
int i = M(1,2); // Calls non-const version since M is not const
M(1,2) = 7; // Calls non-const version since M is not const

const Matrix<int> MConst;
int j = MConst(1,2); // Calls const version since MConst is const

MConst(1,2) = 4; // Calls the const version since MConst is const.
                 // Probably shouldn't compile .. but might since return value is 
                 // T not const T.

int get_first( const Matrix<int> & m )
{
   return m(0,0); // Calls the const version as m is const reference
}

int set_first( Matrix<int> & m )
{
  m(0,0) = 1; // Calls the non-const version as m is not const
}

Answer 3

Welche Funktion aufgerufen wird, hängt davon ab, ob das Objekt const ist. Für const const Überlastung Objekte heißt:

const Matrix<...> mat;
const Matrix<...>& matRef = mat;
mat( i, j);//const overload is called;
matRef(i, j); //const overloadis called

Matrix<...> mat2;
mat2(i,j);//non-const is called
Matrix<...>& mat2Ref = mat2;
mat2Ref(i,j);//non-const is called
const Matrix<...>& mat2ConstRef = mat2;
mat2ConstRef(i,j);// const is called

Das gleiche gilt für Zeiger. Wenn der Anruf über einen Zeiger auf const erfolgt, wird eine konstante Überlastung bezeichnet. Andernfalls wird eine nicht konstante Überlastung bezeichnet wird.