1) Create dynamically filled array in a function. 2) Return the array content

I managed to hack together an inelegant solution as you can see in the code, by wedging a for-loop in the middle of a cout.

Actually, this solution is much more elegant since it avoids the unnecessary cost of a dynamic array.

1. Create dynamically filled array in a function. 2) Return the array content

You can do it like this:

std::vector<int> v; // a dynamic array
// fill the vector here
return v;

You can use a std::vector:

#include <vector>
std::vector<int> factors;
for(int i=2; i<num; i++) {
    if(num%i==0) {
        factors.push_back(i);
    }
}
for(int i:factors) cout<<i;

Actually you can combine both your requirements(checking if a num is prime ad getting all the dividors) into the same function.

I would do it this way

#include <iostream>
#include <set>
#include <cmath>

using namespace std;

static void getDividors(int num, set<int> &divs)
{
    divs.insert(1);
    divs.insert(num);

    if (num == 2)
        return;

    // It is enough to check until the sqrt num..
    int sqRootNum = floor(sqrt(num));

    for (int i = 2; i <= sqRootNum; i++) {
        if (num % i == 0) {
            divs.insert(i);
            divs.insert(num/i);
        }
    }
}

int main() {
    
    int num;
    
    cout<<"Enter a number and we'll check if it's prime: ";
    cin>>num;

    set<int> divs;
    getDividors(num, divs);
    bool isPrime = divs.size() > 2 ? false : true;
    if (isPrime)
        cout<<"Number is prime!";
    else
    {
        cout<<"Not a prime number :( ";
        cout<<"Infact, "<<num<<" can be divided by: ";
        for (const auto &n : divs) {
            cout<< n <<" ";
        }
    }

    return 0;
}

Here is the sample output:

Enter a number and we'll check if it's prime: 16
Not a prime number :( Infact, 16 can be divided by: 1 2 4 8 16 

The complexity of above code is O(sqrt(n)) which makes it very efficient too.

For insertion of elements, i am using set instead of vectors as it will simplify the logic as to not check for duplicates when adding into vector and also will be ordered(elements added to set will be in the ascending order) making it easy to nicely print them.

Since you wrote

The below is quasi human language/c++ code, written to describe what I wanted to achieve.

I'm adding this answer to show a solution that (maybe accepting to change our midset a bit) is truly like human language, because it tells a story, rather then using low lever for loops and if conditionals for which you have to pay attention on whether you've mistakely written <= instead of < and other stuff.

Here it is:

auto dividers = iota(2, num) | transform(both(id, mod(num)))
                             | filter(compose(equal_to(0), get_second))
                             | transform(get_first);

What does it do?

In short:

• takes numbers from 2 to num-1,
• std::pairs them up with the modulo of num by each of them,
• retains only those with 0 modulo,
• pulls the original number throwing away the modulo.

More in detail:

• Iota is the ninth letter of the Greek alphabet, and ranges::views::iota (for which you can refer to std::ranges::views::iota) is such that iota(n) gives you back n, n+1, n+2, n+3, ..., whereas if you pass it a second argument, as in our usecase, it gives you back only numbers up to and not including that: iota(n, n+m) gives n, n+1, n+2, ..., n+m-1.
• For ranges::views::transform you can refer to std::ranges::views::transfrom; we are passing to it both(id, mod(num)) as the transforming function, which, as the name should imply, applies both the identity funtion and mod(num) to its argument and gives you back a pair of those two results (it is not a standard function, I've written it at the bottom of this answer); mod(num), guess what, is such that nod(num)(n) == num % n (ditto, I've defined mod below, as a hana::curryed wrapper to %).
• For ranges::views::filter you can refer to std::ranges::views::filter; we are passing to it the mathematical composition, via boost::hana::compose of two functions: get_second, which takes the second entry of the pair coming from the transform, i.e. the modulo, and equal_to(0) which is predicate testing if something is zero (equal_to is a curried std::equal_to<>{} function object).
• Finally, we are pulling out only the first element of the pairs, via transform(get_first).

As an improvement to the code above, you could add | cache1 between the first of the two tranform and the filter after it. The reason why, is explained in this post here on Stack Overflow and in this post on FluentC++.

Below are the helper functions I've used with each header they need.

std::get is a template function, so it can't be passed around as an object could. BOOST_HOF_LIFT can make an object out of it:

#include <boost/hof/lift.hpp>
#include <utility>
template<int N>
auto constexpr get = BOOST_HOF_LIFT(std::get<N>);

so we can write more verbose getters for our usecase of working on pairs:

auto constexpr get_first = get<0>;
auto constexpr get_second = get<1>;

std::equal_to is already a function object, but we want to be able to pass its two arguments one by one, so we curry it:

#include <boost/hana/functional/curry.hpp>
#include <functional>
auto constexpr equal_to = curry<2>(std::equal_to<>{});

We want to do the same for %, but that's on operator, so we'd have to manually wrap it; luckily the STL offers an object already, namely std::modulus<>{}:

// same two headers as previous one
auto constexpr mod = curry<2>(std::modulus<>{});

Finally, here's my hand-made both (which could be greately improved, generalized):

#include <utility>
auto constexpr both = [](auto const& f1, auto const& f2){
    return [&f1, &f2](auto const& x){
        return std::make_pair(f1(x), f2(x));
    };
};

Here's a working demo on Compiler Explorer.