Перегрузить оператор + в обе стороны

Как-то так:

MyClass & operator += (MyClass &a, int b)
{
  a.value += b;
  return a;
}
MyClass operator + (MyClass a, int b)
{
  return a += b;
}
MyClass operator + (int b, MyClass a)
{
  return a += b;
}

То есть надо 2 раза определять, хоть тело одно?

Да, надо два оператора. Но в приницпе можно сделать второй таким:

MyClass operator + (int b, const MyClass &a)
{
  return a + b;
}

Например, если у вас MyClass имеет конструктор от int - просто определить как свободный (вне класса) оператор

... operator+(const MyClass&,const MyClass&);

Тогда при суммировании просто выполнится неявное преобразование int в MyClass.

Можно - определить два оператора

... operator+(const MyClass&, int);
... operator+(int,const MyClass&);

Первый из них можно определить и как член, и как свободный; второй - только как свободный оператор.

P.S. Как правило, стоит определять сразу же и оператор +=, причем один вполне может определяться через другой...

1. Прямой ответ: написать отдельные перегруженные операторы для всех возможных комбинаций операндов MyClass + int и int + MyClass.

2. Однако, если семантика вашего класса такова, что он натуральным образом поддерживает сложение MyClass + MyClass и также неявное преобразование int -> MyClass (то есть не-explicit конструктор преобразования из типа int), то оператор MyClass + MyClass уже сам по себе будет "покрывать" и сложения MyClass + int и int + MyClass тоже:

   struct MyClass 
   {
     MyClass() = default;
     MyClass(int) {}
     friend MyClass operator +(const MyClass &, const MyClass &)
       { return MyClass(); }
   };
   int main()
   {
     MyClass a;
     a + 123;
     123 + a;
   }
   

   Именно для "симметричности" поведения класса в таких контекстах и рекомендуется реализовывать оператор + отдельностоящей функцией, а не методом класса.