Найти все сочетания с повторениями из букв A, B, C, D заданного размера

#include <iostream>
#include <string>
 
using namespace std;
 
void func(int k) {
    string str = "ABCD";
    if (k > 0) for (const auto &ch1 : str) {
        if (k > 1) for (const auto &ch2 : str) {
            if (k > 2) for (const auto &ch3 : str) {
                if (k > 3) for (const auto &ch4 : str) {
                    cout << ch1 << ch2 << ch3 << ch4 << endl;
                } else cout << ch1 << ch2 << ch3 << endl;
            } else cout << ch1 << ch2 << endl;
        } else cout << ch1 << endl;
    } 
    cout << endl;
}
 
int main() {
    int k;
    cout << "Enter number: ";
    cin >> k;
 
    func(k);
 
    return 0;
}

 #include <iostream>
 //--------------------------------------------------------
 bool next_comb( int index[], const int &n, const int &m )
 {
   int j = m - 1;
       while ( index[ j ] == n && j >= 0 )
          j--;
       if ( j < 0 )
          return false;
       if ( index[ j ] >= n )
          j--;
   index[ j ]++;
      if ( j == m - 1 )
         return true;
      for ( int k = j + 1; k < m; k++ )
         index[ k ] = index[ j ];
   return true;
 }
 //--------------------------------------------------------
 int main()
 {
   char char_set[] = { 'A', 'B', 'C', 'D' };
   int N = sizeof( char_set ) / sizeof( char_set[ 0 ] );
       for( int i = 0; i < N; ++i )
          std::cout << char_set[ i ] << " ";
   std::cout << std::endl;
   int n = 2;
   int k = N > n ? N : n;
   int *index = new int [ k ];
       for ( int i = 0; i < k; i++ )
           index[i] = 1;
       do
       {
             for( int i = 0; i < n; ++i )
                std::cout << char_set[ index[ i ] - 1 ] << " ";
         std::cout << std::endl;
       }
       while ( next_comb( index, N, n ) );
   delete [] index;
   //std::cin.get();
 }

int M = (1 << 2*k); // для 4 умножения можно заменить сдвигом
for(int i = 0; i<M; i++) {
  int n = i;
  for(int j; j<k; j++) {
    cout << 'A' + n%4;
    n /= 4;
  }
  cout << endl;
}

#include <iostream>
#include <iterator>
#include <vector>
 
 
class product 
{
    typedef product* product_ptr;
    typedef std::vector<std::string> vstring;
 
    const vstring data;
    size_t length;
    const size_t repeat;
public:
    class iterator : public std::iterator<
        std::input_iterator_tag,
        std::string,
        long,
        std::string*,
        std::string&> 
    {
        size_t step;
        const product_ptr prod;
    public:
        explicit iterator(const size_t &step, const product_ptr &prod) : step(step), prod(prod) { }
        iterator &operator++() { ++step; return *this; }
        bool operator==(iterator other) const { return step == other.step && prod == other.prod; }
        bool operator!=(iterator other) const { return !(*this == other); }
        std::string operator*() const {
            const size_t len = prod->repeat * prod->data.size();
            char *buffer = new char[len+1]{0};
            size_t i = len - 1, 
                   temp_step = step;
            for (size_t r = 0; r < prod->repeat; ++r) {
                for (vstring::const_reverse_iterator it = prod->data.crbegin(); it != prod->data.crend(); it++) {
                    size_t pos = temp_step % it->size();
                    temp_step /= it->size();
                    buffer[i--] = (*it)[pos];
                }
            }
            return std::string(buffer);
        }
    };
 
    product(const vstring &value, const int repeat=1) : data(value), repeat(repeat) {
        size_t len = 1;
        for (const auto &a : value) len *= a.size();
        length = len;
        for (size_t i = 1; i < repeat; ++i) length *= len;
    }
    iterator begin() const { return iterator(0, product_ptr(this)); }
    iterator end() const { return iterator(length, product_ptr(this)); }
};
 
 
int main() {
    for (const std::string data : product({"ABCD"}, 2)) {
        std::cout << data << std::endl;
    }
}

void combinations(int k, const std::string& alphabet, string s="")
{
    if(k == 0)
        cout << s << endl;
    else
    {
        for(char c : alphabet)
        {
            combinations(k-1, alphabet, s + c);
        }
    }
}

#include <iostream>
#include <string>
 
using namespace std;
 
void func(int k, string str = "ABCD", string chars="") {
    if (k > 0 && k <= str.size()) for (const auto &ch : str) {
        if (k == 1) cout << chars << ch << endl;
        func(k - 1, str, chars + ch);
    }
}
 
int main() {
    int k;
    cout << "Enter number: ";
    cin >> k;
 
    func(k);
 
    return 0;
}

#include <iostream>
#include <iterator>
#include <vector>
 
class product
{
    typedef product *product_ptr;
    typedef std::vector<std::string> vstring;
    typedef std::vector<std::string::const_iterator> vstring_iter;
 
    const vstring data;
    const size_t repeat;
 
  public:
    class iterator : public std::iterator<
                         std::input_iterator_tag,
                         std::string,
                         long,
                         std::string *,
                         std::string &>
    {
        const product_ptr prod;
        vstring_iter iters;
 
      public:
        iterator(const vstring_iter &iters, const product_ptr &prod) : iters(iters), prod(prod) { }
        iterator &operator++();
        bool operator==(const iterator &) const;
        bool operator!=(const iterator &) const;
        std::string operator*() const;
    };
 
    product(const vstring &value, const int repeat = 1) : data(value), repeat(repeat) {}
    iterator begin() const;
    iterator end() const;
};
 
int main()
{
    for (const std::string data : product({"ABCD", "xy"}))
        std::cout << data << std::endl;
    for (const std::string data : product({"01"}, 3))
        std::cout << data << std::endl;
}
 
//
// product implementation
//
 
product::iterator product::begin() const
{
    vstring_iter iters(data.size() * repeat);
    for (size_t i = 0; i < iters.size(); ++i)
        iters[i] = data[i % data.size()].begin();
    return iterator(iters, product_ptr(this));
}
 
product::iterator product::end() const
{
    vstring_iter iters(data.size() * repeat);
    iters[0] = data[0].end();
    for (size_t i = 1; i < iters.size(); ++i)
        iters[i] = data[i % data.size()].begin();
    return iterator(iters, product_ptr(this));
}
 
//
// product::iterator implementation
//
 
product::iterator &product::iterator::operator++()
{
    const size_t data_size = prod->data.size();
    for (int i = iters.size() - 1; i >= 0; --i)
    {
        ++iters[i];
        if (i && iters[i] == prod->data[i % data_size].end())
            iters[i] = prod->data[i % data_size].begin();
        else
            break;
    }
    return *this;
}
 
std::string product::iterator::operator*() const
{
    const size_t len = prod->repeat * prod->data.size();
    char *buffer = new char[len + 1]{ 0 };
    for (int i = len - 1; i >= 0; --i)
        buffer[i] = *iters[i];
    return std::string(buffer);
}
 
bool product::iterator::operator==(const product::iterator &other) const
{
    if (prod != other.prod || iters.size() != other.iters.size())
        return false;
    return iters == other.iters;
}
 
bool product::iterator::operator!=(const product::iterator &other) const { return !(*this == other); }