OOP Design of a Mathematical Group

A group is a triple of a set, an associative binary operation, and the identity element of that binary operation, with the requirement that every element have an inverse.

The element of one group is unrelated to the element of another group, so your idea of having base classes Element and Group is nonsensical. It is also nonsensical to say that an element is associated with exactly one group. 1 isn't associated with just multiplication.

What you can do is define a template Group, that has all three as parameters.

template <typename Operation, typename Element>
concept binary_operation = requires std::is_invocable_r_v<Element, Operation, Element, Element>;

// can't check associativity + presence of inverse with concepts, binary_operation is the best we can do here
template <typename Element, binary_operation<Element> Operation, Element Identity>
class Group {
    Operation operation;
public:
    static constexpr Element identity = Identity;
    Element mul(Element lhs, Element rhs) { return operation(lhs, rhs); }
    Element exp(Element value, std::size_t n) { 
        Element result = identity;
        for (std::size_t i = 0; i < n; ++i) {
            result = mul(value, result);
        }
        return result;
    }
};

using RealMulGroup = Group<double, std::multiplies<>, 1.0>;
using IntPlusGroup = Group<int, std::plus<>, 0>;

Alternatively you could make Group polymorphic for one kind of element.

template <typename Element>
class Group {
public:
    virtual Element mul(Element lhs, Element rhs) const = 0;
    virtual Element identity() const = 0;

    Element exp(Element value, std::size_t n) { 
        Element result = identity();
        for (std::size_t i = 0; i < n; ++i) {
            result = mul(value, result);
        }
        return result;
    }
};

class RealMulGroup : public Group<double> {
public:
    double mul(double lhs, double rhs) const override { return lhs * rhs; }
    double identity() const override { return 1.0; }
};

N.b. I'm not convinced that mul and exp are appropriate names for a general group.

If your main issue is memory allocation, and if you absolutely need to use a reference semantic rather than a value semantic, for example because you want Element to be polymorphic, then just replace the raw pointers with shared pointers:

class Group;  
class Element {
public:
  Element(shared_ptr<Group> group) : group(group) {
  }
private:
  shared_ptr<Group> group;
};

class Group {
public:
  virtual shared_ptr<Element> mul(shared_ptr<Element> a, shared_ptr<Element> b) = 0;
  shared_ptr<Element> exp(shared_ptr<Element> a, unsigned int n) {
    if (n>1) 
        return mul(a, exp(a,n-1)); 
    else return a; 
  }
};

You can then create new elements with make_shared<Element>(...) and get them automatically deleted when the reference count decreases to zero, which will probably happen if you forget to store a mul() result.

This design seems however flawed, because:

• the group does not know its elements;
• nothing ensures that the elements are homogeneous. You could for example combine a IntElement with a StringElement.
• typically the implementation of mul() depends on the exact type of Element.

A better approach would be to use templates. Here a first demo, but of course, not knowing the design constraints, there are certainly things to be refined:

template<class Element>
class Group {
public:
  void add(Element e) {
      set_of_elements.insert(e); // alternatively you could consider that all possible Element values belong to the group
  }
  virtual Element mul(Element a, Element b) = 0;
  Element exp(Element a, unsigned int n) {
    // ideally wwe should start iteration at 0 and the neutral element
    Element res=a; 
    for (int i=1; i<n; i++) 
        res = mul(a, res); 
    return res; 
  }
private: 
  set<Element> set_of_elements; 
};

class MyIntMulGroup : public Group<int> {
public: 
   int mul(int a, int b) override {
      return a*b; 
   }    
}; 

int main() {
    MyIntMulGroup g; 
    cout << g.mul(2,4) << endl; 
    cout << g.exp(2,4) << endl; 
}