Zugriff auf den Operator [] über einen Zeiger

Question

Wenn ich einen Zeiger auf ein Objekt definiere, das die [] Operator, gibt es eine direkte Möglichkeit, auf diesen Operator von einem Zeiger aus zuzugreifen?

Zum Beispiel kann ich im folgenden Code direkt auf Vec Mitgliedsfunktionen (wie z.B. empty() ) durch Verwendung des Zeigerwerts -> Operator, aber wenn ich auf die [] Operator muss ich zunächst einen Verweis auf das Objekt erhalten und dann den Operator aufrufen.

#include <vector>

int main(int argc, char *argv[])
{
    std::vector<int> Vec(1,1);
    std::vector<int>* VecPtr = &Vec;

if(!VecPtr->empty())      // this is fine
    return (*VecPtr)[0]; // is there some sort of ->[] operator I could use?

return 0;
}

Ich kann mich durchaus irren, aber es sieht so aus, als ob (*VecPtr).empty() ist weniger effizient als die Durchführung VecPtr->empty() . Deshalb suchte ich nach einer Alternative zu (*VecPtr)[] .

Answer 1

Sie könnten eine der folgenden Möglichkeiten nutzen:

#include <vector>

int main () {
  std::vector<int> v(1,1);
  std::vector<int>* p = &v;

  p->operator[](0);
  (*p)[0];
  p[0][0];
}

Übrigens, in dem besonderen Fall von std::vector können Sie auch wählen: p->at(0) auch wenn es eine etwas andere Bedeutung hat.

Answer 2

return VecPtr->operator[](0);

...wird den Zweck erfüllen. Aber wirklich, die (*VecPtr)[0] Form sieht schöner aus, nicht wahr?

Answer 3

(*VecPtr)[0] ist völlig in Ordnung, aber Sie können die at Funktion, wenn Sie möchten:

VecPtr->at(0);

Beachten Sie, dass dies (im Gegensatz zu operator[] ) wird eine std::out_of_range Ausnahme, wenn der Index nicht im Bereich liegt.

Answer 4

Es gibt noch eine andere Möglichkeit: Sie können einen Verweis auf das Objekt verwenden:

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> v = {7};
    vector<int> *p = &v;

    // Reference to the vector
    vector<int> &r = *p;
    cout << (*p)[0] << '\n'; // Prints 7
    cout <<    r[0] << '\n'; // Prints 7

    return 0;
}

Hier entlang, r ist dasselbe wie v und Sie können alle Vorkommen von (*p) von r .

Vorbehalt: Dies funktioniert nur, wenn Sie wird den Zeiger nicht verändern (d.h. ändern, auf welches Objekt er zeigt).

Bedenken Sie Folgendes:

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> v = {7};
    vector<int> *p = &v;

    // Reference to the vector
    vector<int> &r = *p;
    cout << (*p)[0] << '\n'; // Prints 7
    cout <<    r[0] << '\n'; // Prints 7

    // Caveat: When you change p, r is still the old *p (i.e. v)
    vector<int> u = {3};
    p = &u; // Doesn't change who r references
    //r = u; // Wrong, see below why
    cout << (*p)[0] << '\n'; // Prints 3
    cout <<    r[0] << '\n'; // Prints 7

    return 0;
}

r = u; ist falsch, weil man die Referenzen nicht ändern kann: Dies wird den Vektor ändern, auf den mit r ( v ) anstatt einen anderen Vektor zu referenzieren ( u ). Also, wieder, dies funktioniert nur, wenn der Zeiger nicht ändern, während noch mit der Referenz.

Die Beispiele benötigen C++11 nur wegen der vector<int> ... = {...};

Answer 5

Sie können es verwenden als VecPrt->operator [] ( 0 ) aber ich bin mir nicht sicher, ob Sie es weniger obskur finden werden.