могут ли пользовательские классы C ++ воспроизводить производительность встроенных типов?

Я пытаюсь создать класс C ++, который ведет себя точно так же, как встроенный тип int с одним исключением: везде, где вызывается этот оператор * (или оператор * =), добавляется вызывается вместо этого.

Сначала производительность моего класса была очень низкой (1/2 от встроенного типа int ), но я заметил, что это произошло потому, что я забыл включить конструктор копирования ниже :

struct AlmostInt {                                                                                                                                                                       

  AlmostInt () { }                
  AlmostInt (const AlmostInt  &a) : val(a.val) { }  // forgetting this killed
                                                    // performance

  AlmostInt operator+(const AlmostInt &a) const { AlmostInt result = *this;
                                          result.val += a.val;
                                          return result; }
  AlmostInt operator-(const AlmostInt &a) const { AlmostInt result = *this;
                                          result.val -= a.val;
                                          return result; }
  AlmostInt operator*(const AlmostInt &a) const { AlmostInt result = *this;
                                          result.val  = result.val + a.val;      
                                          return result; }
  AlmostInt &operator+=(const AlmostInt &a) { this->val += a.val;                           
                                              return *this; }
  AlmostInt &operator-=(const AlmostInt &a) { this->val -= a.val;        
                                              return *this; }
  AlmostInt &operator*=(const AlmostInt &a) { this->val = this->val + a.val);     
                                              return *this; }

private:
  int val;
};

К сожалению, моя программа остается на 25% медленнее, чем должна быть. Изучая сборку, созданную для двух разных версий программы (одна с использованием int , другая с использованием ПочтиInt ), я вижу, что существует одинаковое количество операций + и -, поэтому все "работает" на каком-то уровне.

Проблема в том, что в коде значительно больше операций загрузки и сохранения, использующих класс ПочтиInt , а не собственную операцию int .

Есть ли у кого-нибудь идеи, откуда могут взяться эти накладные расходы? Единственное предположение У меня было такое, что, возможно, компилятор не понимает, что ПочтиInt имеет все те же свойства int (например, ассоциативность, коммутативность), но если бы это было действительно проблема, я бы ожидал другого количества инструкций '+' или '-' в коде, но этого не происходит.

Я подозреваю, что дополнительные загрузки и сохранения связаны с дополнительной активностью стека, но все, что я могу сказать на данный момент, это не просто несколько дополнительных загрузок и сохранений стека в сверху и снизу каждой функции, но дополнительные загрузки и сохранения происходят по всему коду.

Есть идеи? Интересно, может ли кто-нибудь указать мне на компилятор, который разрешает один, чтобы достичь уровня производительности int с помощью специального класса.

ОБНОВЛЕНИЕ:

Вот простая функция, которую вы можете вырезать и вставить, чтобы увидеть, что происходит самостоятельно. В x86-64 Linux (g ++ 4.3, 4.4), AIX6 xlC и нескольких других платформах изменение строки «ВЫБРАТЬ ОДИН ...» ниже должно привести к генерации того же кода (или, по крайней мере, код такой же производительности), но на практике код значительно раздувается. Может ли кто-нибудь объяснить, что происходит (для какой-либо конкретной платформы / компилятора) или как это исправить?

class AlmostInt
{
    int value;

public:

    AlmostInt& operator+=(AlmostInt that)
    {
        value += that.value;
        return *this;
    }

    AlmostInt& operator-=(AlmostInt that)
    {
        value -= that.value;
        return *this;
    }

        AlmostInt& operator*=(AlmostInt that)
    {
        value *= that.value;
        return *this;
    }
};

AlmostInt operator+(AlmostInt lhs, AlmostInt rhs)
{
    lhs += rhs;
    return lhs;
}

AlmostInt operator-(AlmostInt lhs, AlmostInt rhs)
{
    lhs -= rhs;
    return lhs;
}

AlmostInt operator*(AlmostInt lhs, AlmostInt rhs)
{
    lhs *= rhs;
    return lhs;
}

// CHOOSE ONE OF THE FOLLOWING TWO LINES:
//typedef int real;
typedef AlmostInt real;

typedef struct {
  real re;
  real im;
} complex;

#define R(a0,a1,b0,b1,wre,wim) { \
  t1 = a0 - a1;  t2 = b0 - b1; \
  t5 = t1 * wim; t6 = t2 * wim; \
  t3 = a0;  t1 *= wre; \
  t3 += a1; t2 *= wre; \
  t1 -= t6; t4 = b0; \
  t2 += t5; t4 += b1; \
  a0 = t3;  b1 = t2; \
  a1 = t4;  b0 = t1; \
}

#define RZERO(a0,a1,b0,b1) { \
  t1 = a0 - a1; t2 = b0 - b1; \
  t3 = a0 + a1; t4 = b0 + b1; \
  b0 = t1; a0 = t3; \
  b1 = t2; a1 = t4; \
}

void rpass(real *a, const complex *w, unsigned int n)
{
  real t1, t2, t3, t4, t5, t6, t7, t8;
  real *b;
  unsigned int k;

  b = a + 4 * n;
  k = n - 2;

  RZERO(a[0],a[1],b[0],b[1]);
  R(a[2],a[3],b[2],b[3],w[0].re,w[0].im);
  R(a[4],a[5],b[4],b[5],w[1].re,w[1].im);
  R(a[6],a[7],b[6],b[7],w[2].re,w[2].im);

  for (;;) {
    R(a[8],a[9],b[8],b[9],w[3].re,w[3].im);
    R(a[10],a[11],b[10],b[11],w[4].re,w[4].im);
    R(a[12],a[13],b[12],b[13],w[5].re,w[5].im);
    R(a[14],a[15],b[14],b[15],w[6].re,w[6].im);
    if (!(k -= 2)) break;
    a += 8;
    b += 8;
    w += 4;
  }
}

(Кредит, где следует отдать должное: этот небольшой тест взят из библиотеки 'djbfft' Дэна Бернштейна)