Указатель на элемент структуры [дубликат]

Это позволяет единообразно связывать переменные-члены и функции. Ниже приведен пример вашего класса Car. Более частое использование было бы привязкой std::pair::first и ::second при использовании в алгоритмах STL и Boost на карте.

#include <list>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>


class Car {
public:
    Car(int s): speed(s) {}
    void drive() {
        std::cout << "Driving at " << speed << " km/h" << std::endl;
    }
    int speed;
};

int main() {

    using namespace std;
    using namespace boost::lambda;

    list<Car> l;
    l.push_back(Car(10));
    l.push_back(Car(140));
    l.push_back(Car(130));
    l.push_back(Car(60));

    // Speeding cars
    list<Car> s;

    // Binding a value to a member variable.
    // Find all cars with speed over 60 km/h.
    remove_copy_if(l.begin(), l.end(),
                   back_inserter(s),
                   bind(&Car::speed, _1) <= 60);

    // Binding a value to a member function.
    // Call a function on each car.
    for_each(s.begin(), s.end(), bind(&Car::drive, _1));

    return 0;
}

Я думаю, вы только хотели бы сделать это, если бы данные элемента были довольно большими (например, объект другого довольно здоровенного класса), и у вас есть внешняя подпрограмма, которая работает только с ссылками на объекты этого класса. Вы не хотите копировать объект-член, поэтому это позволяет вам передавать его.

Указатели на классы не являются действительными указателями; класс является логической конструкцией и не имеет физического существования в памяти, однако, когда вы строите указатель на член класса, он дает смещение в объект класса члена, где элемент может быть найден; Это дает важный вывод: Поскольку статические члены не связаны с каким-либо объектом, поэтому указатель на элемент НЕ МОЖЕТ указывать на статический член (данные или функции) вообще . Рассмотрим следующее:

class x
{
public:
int val;
x(int i) { val=i;}

int get_val(){return val;}
int d_val(int i){return i+i;}
};
int main()
{
int (x::*data)=&x::val;               //pointer to data member
int (x::*func)(int)=&x::d_val;        //pointer to function member
x ob1(1),ob2(2);
cout<<ob1.*data;
cout<<ob2.*data;
cout<<(ob1.*func)(ob1.*data);
cout<<(ob2.*func)(ob2.*data);
return 0;
}

Источник: полный справочник C ++ - Herbert Schildt 4th Edition

Просто добавьте некоторые варианты использования для @ anon's & amp; @ Ответ Oktalist, вот отличный материал для чтения о функции указателя на член и данные указателя на член. http://www.cs.wustl.edu/~schmidt/PDF/C++-ptmf4.pdf

Вы можете использовать массив указателей на (однородные) данные элемента, чтобы включить двойной интерфейс с именем-членом (например, x.data) и массивом-индексом (например, x [idx]).

#include <cassert>
#include <cstddef>

struct vector3 {
    float x;
    float y;
    float z;

    float& operator[](std::size_t idx) {
        static float vector3::*component[3] = {
            &vector3::x, &vector3::y, &vector3::z
        };
        return this->*component[idx];
    }
};

int main()
{
    vector3 v = { 0.0f, 1.0f, 2.0f };

    assert(&v[0] == &v.x);
    assert(&v[1] == &v.y);
    assert(&v[2] == &v.z);

    for (std::size_t i = 0; i < 3; ++i) {
        v[i] += 1.0f;
    }

    assert(v.x == 1.0f);
    assert(v.y == 2.0f);
    assert(v.z == 3.0f);

    return 0;
}

Предположим, что у вас есть структура. Внутри этой структуры есть * какое-то имя * две переменные одного и того же типа, но с различным значением

struct foo {
    std::string a;
    std::string b;
};

Хорошо, теперь предположим, что у вас есть куча foo s в контейнере:

// key: some sort of name, value: a foo instance
std::map<std::string, foo> container;

Хорошо, теперь предположим, что вы загружаете данные из разных источников, но данные представляются одинаково (например, вам нужен тот же метод синтаксического анализа).

Вы могли бы сделайте что-то вроде этого:

void readDataFromText(std::istream & input, std::map<std::string, foo> & container, std::string foo::*storage) {
    std::string line, name, value;

    // while lines are successfully retrieved
    while (std::getline(input, line)) {
        std::stringstream linestr(line);
        if ( line.empty() ) {
            continue;
        }

        // retrieve name and value
        linestr >> name >> value;

        // store value into correct storage, whichever one is correct
        container[name].*storage = value;
    }
}

std::map<std::string, foo> readValues() {
    std::map<std::string, foo> foos;

    std::ifstream a("input-a");
    readDataFromText(a, foos, &foo::a);
    std::ifstream b("input-b");
    readDataFromText(b, foos, &foo::b);
    return foos;
}

. В этот момент при вызове readValues() будет возвращен контейнер с унисоном «input-a» и «input-b»; все клавиши будут присутствовать, а foos имеют либо a, либо b или оба.

Еще одно приложение - это интрузивные списки. Тип элемента может рассказать о том, каковы его следующие / предыдущие указатели. Таким образом, список не использует жестко заданные имена, но все равно может использовать существующие указатели:

// say this is some existing structure. And we want to use
// a list. We can tell it that the next pointer
// is apple::next.
struct apple {
    int data;
    apple * next;
};

// simple example of a minimal intrusive list. Could specify the
// member pointer as template argument too, if we wanted:
// template<typename E, E *E::*next_ptr>
template<typename E>
struct List {
    List(E *E::*next_ptr):head(0), next_ptr(next_ptr) { }

    void add(E &e) {
        // access its next pointer by the member pointer
        e.*next_ptr = head;
        head = &e;
    }

    E * head;
    E *E::*next_ptr;
};

int main() {
    List<apple> lst(&apple::next);

    apple a;
    lst.add(a);
}

Это самый простой пример, который я могу себе представить, который передает редкие случаи, когда эта особенность уместна:

#include <iostream>

class bowl {
public:
    int apples;
    int oranges;
};

int count_fruit(bowl * begin, bowl * end, int bowl::*fruit)
{
    int count = 0;
    for (bowl * iterator = begin; iterator != end; ++ iterator)
        count += iterator->*fruit;
    return count;
}

int main()
{
    bowl bowls[2] = {
        { 1, 2 },
        { 3, 5 }
    };
    std::cout << "I have " << count_fruit(bowls, bowls + 2, & bowl::apples) << " apples\n";
    std::cout << "I have " << count_fruit(bowls, bowls + 2, & bowl::oranges) << " oranges\n";
    return 0;
}

Здесь следует отметить указатель, переданный в count_fruit. Это избавит вас от необходимости писать отдельные функции count_apples и count_oranges.