### 12.6 C++ Interface Limitations

`mpq_class` and Templated Reading

  A generic piece of template code probably won’t know that `mpq_class` requires a `canonicalize` call if inputs read with `operator>>` might be non-canonical. This can lead to incorrect results.

  `operator>>` behaves as it does for reasons of efficiency. A canonicalize can be quite time consuming on large operands, and is best avoided if it’s not necessary.

  But this potential difficulty reduces the usefulness of `mpq_class`. Perhaps a mechanism to tell `operator>>` what to do will be adopted in the future, maybe a preprocessor define, a global flag, or an `ios` flag pressed into service. Or maybe, at the risk of inconsistency, the `mpq_class` `operator>>` could canonicalize and leave `mpq_t` `operator>>` not doing so, for use on those occasions when that’s acceptable. Send feedback or alternate ideas to gmp-bugs@gmplib.org.

Subclassing

  Subclassing the GMP C++ classes works, but is not currently recommended.

  Expressions involving subclasses resolve correctly (or seem to), but in normal C++ fashion the subclass doesn’t inherit constructors and assignments. There’s many of those in the GMP classes, and a good way to reestablish them in a subclass is not yet provided.

Templated Expressions

  A subtle difficulty exists when using expressions together with application-defined template functions. Consider the following, with `T` intended to be some numeric type,

      template <class T>
      T fun (const T &, const T &);

  When used with, say, plain `mpz_class` variables, it works fine: `T` is resolved as `mpz_class`.

      mpz_class f(1), g(2);
      fun (f, g);    // Good

  But when one of the arguments is an expression, it doesn’t work.

      mpz_class f(1), g(2), h(3);
      fun (f, g+h);  // Bad

  This is because `g+h` ends up being a certain expression template type internal to `gmpxx.h`, which the C++ template resolution rules are unable to automatically convert to `mpz_class`. The workaround is simply to add an explicit cast.

      mpz_class f(1), g(2), h(3);
      fun (f, mpz_class(g+h));  // Good

  Similarly, within `fun` it may be necessary to cast an expression to type `T` when calling a templated `fun2`.

      template <class T>
      void fun (T f, T g)
      {
        fun2 (f, f+g);     // Bad
      }

      template <class T>
      void fun (T f, T g)
      {
        fun2 (f, T(f+g));  // Good
      }

C++11

  C++11 provides several new ways in which types can be inferred: `auto`, `decltype`, etc. While they can be very convenient, they don’t mix well with expression templates. In this example, the addition is performed twice, as if we had defined `sum` as a macro.

      mpz_class z = 33;
      auto sum = z + z;
      mpz_class prod = sum * sum;

  This other example may crash, though some compilers might make it look like it is working, because the expression `z+z` goes out of scope before it is evaluated.

      mpz_class z = 33;
      auto sum = z + z + z;
      mpz_class prod = sum * 2;

  It is thus strongly recommended to avoid `auto` anywhere a GMP C++ expression may appear.