LeetCode 894: All Possible Full Binary Trees
Make clone_tree() private
Make helper functions that are not part of the public API private.
Avoid unnecessary nesting of statements if possible
In allPossibleFBT() there's a lot of indentation. There's a risk of the code running off the right hand side of the screen, making it hard to read. Try to reduce nesting if possible (but only if it improves readability and maintainability). In this case, you can get rid of the outermost if-statements by doing an early return if n is even, and then unconditionally adding the single-node tree:
static std::vector&lt;TreeNode *&gt; allPossibleFBT(const size_t n) {
    // Exit early if n is even
    if ((n &amp; 1) == 0)
        return {};

    // Start with the one-node tree
    std::vector&lt;TreeNode *&gt; full_binary_trees{new TreeNode(0)};

    // Add more complex trees
    for (size_t index = 2; ...) {
        ...
    }

    return full_binary_trees;
}

Take a reference of an object if you are using it a lot
When we see a common expression being reused a lot, we can create a new variable holding the result of that expression. When the expression is actually an object, and we don't want to copy the object, we can still avoid repeating the expression by creating a reference to that object. So instead of explicitly writing full_binary_trees.back() many times, write:
auto &amp;root = full_binary_trees.emplace_back(new TreeNode(0));

if (right_index == right_size() - 1) {
    root-&gt;left = ...

Since C++17, emplace_back() returns a reference to the emplaced element. In case you are writing code for older standards, you could write:
full_binary_trees.emplace_back(new TreeNode(0));
auto &amp;root = full_binary_trees.back();
...

But perhaps it would even be better to first created the new tree, and then append it to the vector at the end:
auto root = new TreeNode(0);

if ...

full_binary_trees.emplace_back(root);

Other possible improvements
It would be nice to get rid of the inner-most if-statements, which is possible if you don't care about memory leaks:
for (auto left: allPossibleFBT(index - 1)) {
    for (auto right: allPossibleFBT(n - index)) {
        auto root = new TreeNode(0);
        root-&gt;left = clone_tree(left);
        root-&gt;right = clone_tree(right);
        full_binary_trees.emplace_back(root);
    }
}

In the context of this LeetCode problem, which doesn't state whether or not you are allowed to link a node into multiple trees, you might even get away with not calling clone_tree() at all, but just writing root-&gt;left = left; root-&gt;right = right.
Also note that this problem might benefit from memoization.