Frage zu C++

[Dummjahn (Gast)]

Hallo,

was ist hier 'auto bar = &Foo::bar;" und wozu ist es gut? Adresse von 
... ist ohne Instanz doch sinnlos?

struct Foo {
  Foo() : bar(nullptr) { }
  Foo* bar;
};

auto bar = &Foo::bar;

[g457 (Gast)]

> was ist hier 'auto bar = &Foo::bar;" [..]

Wenns definiert wäre dann wärs vom Typ Foo**

>  [..] und wozu ist es gut?

Zu nix.

[DPA (Gast)]

Dummjahn schrieb:
> &Foo::bar

Ich gehe mal davon aus, dass das in nem anderen Context steht? 
(eventuell mehrfachvererbung mit mehreren bar membern in ner methode 
drin)? Andernfalls müsste bar doch static sein, damit das geht?

[Ntldr -. (ntldr)]

Das ist ein Pointer auf eine Membervariable - ähnlich wie ein Pointer 
auf eine Memberfunktion.

Damit kannst du dann mit einer Instanz die dazugehörige Membervariable 
auslesen. In der Praxis braucht man das aber sogut wie nie. Vor C++11 
war das noch an einigen Stellen sinnvoll, aber heute würde ich fast 
überall ein Lambda vorziehen. Auch weil dieses Sprachfeature eher 
unbekannt ist.

edit
Hier nochmal ein (schlechtes) Beispiel zur theoretischen Verwendung:

template<typename T, typename R>
std::vector<R> map(const std::vector<T>& objects, R T::*var)
{
    std::vector<R> out;
    for(const auto& object : objects)
    {
        out.emplace_back(&object->*var);
    }
    return out;
}


struct Foo 
{
    int a;
    float b;
};

int main()
{
    std::vector<Foo> f;
    map(f, &Foo::a); // Liste der ints 
    map(f, &Foo::b); // Liste der floats
}

Mit nem aktuellen Standard wäre aber ein Lambda deutlich lesbarer (und 
ab C++20 wären Ranges dafür auch von Vorteil).

[Oliver S. (oliverso)]

guggst du hier:

https://riptutorial.com/cplusplus/example/6997/pointers-to-member-variables

Kennt keiner, braucht keiner, hilft keinem.

Oliver

[Rolf M. (rmagnus)]

Im Gegensatz zu Zeigern auf Memberfunktionen habe ich Zeiger auf 
Membervariablen auch noch nie gebraucht.

g457 schrieb:
>> was ist hier 'auto bar = &Foo::bar;" [..]
>
> Wenns definiert wäre dann wärs vom Typ Foo**

Nein, es ist vom Typ Foo* Foo::*

[Dummjahn (Gast)]

Vielen Dank, besonders für das Beispiel und den Link. Ja, Zeiger auf 
Membervariable. Zeiger auf Memberfunktionen kannte ich, war aber wohl zu 
doof und/oder zu müde, um diese kleine Transferleistung zu erbringen.
Hier ist noch ein Beispiel (aus "C++ Templates - The Complete Guide, 2nd 
Edition"):

// define binary tree structure and traverse helpers:
struct Node {
  int value;
  Node* left;
  Node* right;
  Node(int i=0) : value(i), left(nullptr), right(nullptr) { }
  //...
};

auto left = &Node::left;
auto right = &Node::right;

// traverse tree, using fold expression:
template<typename T, typename... TP>
Node* traverse (T np, TP... paths) {
  return (np ->* ... ->* paths); // np ->* paths1 ->* paths2 ...
}
  
int main()
{
  // init binary tree structure:
  Node* root = new Node{0};
  root->left = new Node{1};
  root->left->right = new Node{2};
  //...

  // traverse binary tree:
  Node* node = traverse(root, left, right);
  //...
}