Какая разница между a.b и a->b?

Как это - "нет разницы"?

Первое работает с самим объектом (ссылкой), второе - с указателем.

Типа

struct A {
    int b;
} a, * ptr;

Вы не сможете работать с a->b, как и с ptr.b - только a.b и ptr->b или (*ptr).b.

Если вы не переопределяете оператор -> - то разницы никакой, это просто варианты записи одного и того же...

a->b подразумевает (*a).b

То есть -> используется, если у нас есть указатель на объект и мы хотим получить его поле.

Вы говорите

"У меня есть код, с двумя вариантами,... "

Нам неизвестно какой код у вас имеется. Например, если у меня(у вас) имеется такие структуры:

struct B {
    int first = 5;  
};
struct A {
    B b;
    int first = b.first + 1;
    B* operator->() { return &b; }
};

то вполне можно записать два варианта одного и того же кода:

A a;
//первый вариант
int version1() { 
    //...       
    return a.first - 1;
}
// второй вариант
int version2() {  
    //...   
    return a->first ;
}

1. Результатом первой функции является значение first из структуры A(A::first == B::first` == 6) минус 1.

2. Результатом второй функции будет уже B::first == 5. Оба варианта будут работать с тем же значением, содержащимся в разных обьектах.

   Так что, все таки, выражения a.first и a->first могут существовать одновременно и иметь разный результат

Перегрузка -> имеет смысл когда объект подразумевает абстрактную ссылку на что-то.

# include <iostream>
class Int {
public:
  int i;
};
template  < class T >
class Link {
public :
  Link ( T & t ):secret(&t){}
  T * operator -> (void) { return secret ; }
private :
  T * secret ;
};
void f (  Link<Int> l  ) {
  l->i = 7 ;
  }
int main(){
  Int i;
  f(i);
  std::cout<<"i.i="<<i.i<<"\n";
  }

Это всего-лишь для красоты, чтобы понять, что объект Link на что-то указывает.