Зачем мне оператор .* в С++?

Ваш пример слишком тривиален, чтобы быть иллюстративным. Рассмотрим немного более сложный

struct A {
    int a;
    int b;
};

void set_n_members(A objs[], unsigned n, int A::* ptr, int val)
{
  for (unsigned i = 0; i < n; ++i)
     objs[i].*ptr = val;
}

int main()
{
    A objs[100];
    set_n_members(objs, 100, &A::b, 5);
    set_n_members(objs, 100, &A::a, 7);
}

Как бы вы переписали это без int A::* ptr и без раздувания кода?

Вы можете создавать коллекции указателей на члены и перебирать их. Например.:

struct UserStrings
{
    std::string first_name;
    std::string surname;
    std::string preferred_name;
    std::string address;
};

...

std::array<std::string UserStrings::*, 4> str_cols = { &UserStrings::first_name, &UserStrings::surname, &UserStrings::preferred_name, &UserStrings::address };
std::vector<UserStrings> users = GetUserStrings();

for (auto& user : users)
{
    for (auto& column : str_cols)
    {
        SanitizeForSQLQuery(user.*column);
    }
}

Он используется для реализации std::mem_fn, который используется для реализации std::function.

В следующем коде показано, как работает оператор ->* в простой реализации класса Function.

Точно так же вы можете реализовать класс вызывающего члена, используя оператор .* и ссылку на класс.

#include <iostream>

class A
{
public:
    void greet()
    {
        std::cout << "Hello world"<<std::endl;
    }
};

template<typename R, typename ...TArgs>
class Invoker 
{
public:
    virtual R apply(TArgs&& ...args) = 0;
};

template<typename C, typename R, typename ...TArgs>
class MemberInvoker :public Invoker<R, TArgs...>
{
protected:
    C*                          sender;
    R(C::*function)(TArgs ...args);

public:
    MemberInvoker(C* _sender, R(C::*_function)(TArgs ...args))
        :sender(_sender)
        , function(_function)
    {
    }

    virtual R apply(TArgs&& ...args) override
    {
        return (sender->*function)(std::forward<TArgs>(args)...);
    }
};

template<typename T>
class Func
{
};

template<typename R, typename ...TArgs>
class Func<R(TArgs...)>
{
public:
    Invoker<R,TArgs...>* invoker=nullptr;

    template<typename C>
    Func(C* sender, R(C::*function)(TArgs...))
    {
        invoker =new MemberInvoker<C, R, TArgs...>(sender, function);
    }

    R operator()(TArgs&& ...args)
    {
        return  invoker->apply(std::forward<TArgs>(args)...);
    }

    ~Func()
    {
        if (invoker)
        {
            delete invoker;
            invoker = nullptr;
        }
    }
};

int main()
{
    A a;
    Func<void()> greetFunc(&a, &A::greet);
    greetFunc();
    system("PAUSE");
}

Допустим, вы хотите написать библиотеку стилей LINQ для C++, которую можно использовать примерно так:

struct Person
{
    std::string first_name;
    std::string last_name;
    std::string occupation;
    int age;
    int children;
};

std::vector<Person> people = loadPeople();
std::vector<std::string> result = from(people)
     .where(&Person::last_name == "Smith")
     .where(&Person::age > 30)
     .select("%s %s",&Person::first_name,&Person::last_name);
for(std::string person : result) { ... };

Под прикрытием функция where принимает дерево выражений, содержащее указатель на элемент (среди прочего), и применяется к каждому элементу вектора в поисках подходящего. Оператор select принимает строку формата и некоторый указатель на элементы и выполняет форматирование в стиле sprintf любых элементов вектора, которые проходят через операторы where.

Я написал что-то подобное, и есть несколько других, которые делают это немного по-другому (Есть ли библиотека LINQ для C++?). Указатель на член позволяет пользователю библиотеки указывать любые члены своей структуры, которые ему нужны, и библиотеке не нужно ничего знать о том, что они могут делать.