打印所有子向量组合 + 问题

我正在尝试创建一个工具，使我的生活更轻松，可以根据数字加法设置配置设置列表，以指示应启用哪些功能。 我正在使用从 1 到 512 的 2 次幂列表 （1,2,4,8,16,32,64,128,256,512）。

手动浏览并创建哪些值将启用哪些功能的列表将非常耗时，因此我正在尝试以编程方式执行此操作，然后将输出保存到文件中。 但是，我在寻找适当解决方案时遇到了问题。

我已经阅读了 SO 和其他编码论坛上关于这个主题的几乎所有问题，这些问题都涉及线性组合。 我能够做到这一点，我有这个示例代码，我对其进行了更改，然后在以下基础上构建了我的工具：

    #include <iostream>
using std::cout;
using std::cin;
using std::endl;
// A is the array that contains the numbers
// comb is an array of size k that will hold all possible combinations
// n is the size of input array
// k is 1 less than the size of combination i.e. we want to find out 4C2 k =1
// current_k is the variable that makes us simulates k loops in a recursive function
void combinations(int A[], int comb[], int start, int n, int current_k, int k){
    int sum = 0;
    if (k < 0)
        return;
    // Base case just print all the numbers 1 at a time
    if (k == 0){
        for (int i = 0; i < n; i++)
            cout << A[i] << endl;
    }
    // current_k goes from 0 to k-1 and simulates a total of 
    // k iterations
    if (current_k < k){
        // if current_k = 0, and k = 3 (i.e. we need to find combinations of 4) 
        // then we need to leave out 3 numbers from the end because there are 3
        // more nested loops
        for (int i = start; i < n - (k - current_k); i++){
            // Store the number in the comb array and recursively call with the remaining sub-array
            comb[current_k] = A[i];
            // This will basically pass a sub array starting at index 'start' and going till n-1
            combinations(A, comb, i+1, n, current_k+1, k);
        }
    }
    else if (current_k == k){
        for (int i = start; i < n; i++){
            comb[current_k] = A[i];
            for (int j = 0; j <= k; j++){
                sum += comb[j];     
            }
            
            cout << sum << endl;
            sum = 0;
        }
    }
    else
        return;
}
int main(){
    int n;
    cout << "Enter the 'n' " << endl;
    cin >> n;
    int *A = new int[n];
    for (int i = 0; i < n; i++)
        A[i] = i+1;
    int k;
    cout << "Enter 'k'" << endl;
    cin >> k;
    int *comb = new int[k];
    combinations(A, comb, 0, n, 0, k-1);
    system("pause");
    return 0;
}

唯一的问题是我还需要非线性组合。 比如 1+64+256。 这也能拾起这些组合吗？ 而且我也遇到了一个问题，我将在发布代码后解释。 这是我为此使用的实际代码：

#include <iostream>
#include <vector>
#include <string>
#include "mcl.h"
using std::cout;
using std::vector;
using std::string;
using std::cin;
using std::endl;
static vector<string> results;
// A is the array that contains the numbers
// comb is an array of size k that will hold all possible combinations
// n is the size of input array
// k is 1 less than the size of combination i.e. we want to find out 4C2 k =1
// current_k is the variable that makes us simulates k loops in a recursive function
void combinations(vector<mcl> A, vector<mcl> comb, int start, int n, int current_k, int k){
    string sum;
    string sNames;
    int sCodes = 0;
    if (k < 0)
        k = 0;
    // Base case just print all the numbers 1 at a time
    if (k == 0){
        for (int i = 0; i < n; i++)
            cout << A.at(i).getCode() << " - " << A.at(i).getName() << endl;
        return;
    }
    // current_k goes from 0 to k-1 and simulates a total of 
    // k iterations
    if (current_k < k){
        // if current_k = 0, and k = 3 (i.e. we need to find combinations of 4) 
        // then we need to leave out 3 numbers from the end because there are 3
        // more nested loops
        for (int i = start; i < n - (k - current_k); i++){
            // Store the number in the comb array and recursively call with the remaining sub-array
            comb.push_back(mcl(A.at(i).getCode(),A.at(i).getName()));
            // This will basically pass a sub array starting at index 'start' and going till n-1
            combinations(A, comb, i + 1, n, current_k + 1, k);
        }
    }
    else if (current_k == k){
        for (int i = start; i < n; i++){
            comb.at(current_k-1) = A.at(i);
            for (int j = 0; j < k; j++){
                sCodes += comb.at(j).getCode();
                if (sNames != ""){
                    sNames = sNames + "," + comb.at(j).getName();
                }
                else{
                    sNames = sNames + comb.at(j).getName();
                }
            }
        }
        results.push_back(sCodes + " - " + sNames);
        sCodes = 0;
        sNames = "";
    }
    else
        return;
}
int main(){
    int k;
    vector<mcl> A,comb;
    A.push_back(mcl(1, "Light"));
    A.push_back(mcl(2, "Bright"));
    A.push_back(mcl(4, "Dark"));
    k = 2;
    
    combinations(A, comb, 0, A.size(), 0, k - 1);
    //system("cls");
    for (int i1 = 0; i1 < results.size(); i1++){
        cout << results.at(i1) << endl;
    }
    system("pause");
    return 0;
}

MCL 标头和 imp 代码：

#ifndef MCL_H
#define MCL_H
#include <string>
using std::string;
class mcl{
public:
    mcl(int code, string name);
    int getCode();
    string getName();
    void setCode(int i);
    void setName(string s);
private:
    int cCode;
    string cName;
};
#endif;

小鬼：

#include "mcl.h";
mcl::mcl(int code, string name){
    cCode = code;
    cName = name;
}
int mcl::getCode(){
    return cCode;
}
string mcl::getName(){
    return cName;
}
void mcl::setCode(int i){
    cCode = i;
}
void mcl::setName(string s){
    cName = s;
}

现在是问题。 当我尝试测试我在代码中定义的三个 mcl 对象组合的显示时，我看到以下输出：

明亮，黑暗

黑暗

按任意键继续 . . .

当我看到每个对象的数据正确显示时，如果我将 k 设置为 0：

1 - 光

2 - 明亮

4 - 深色

按任意键继续 . . .

我认为这个问题是由创建用于显示的结果向量的 for 循环引起的，但我不确定实际问题是什么。

至于我预期输出的示例，鉴于上面代码中的硬编码元素，这就是我试图让工具输出的内容（其中粗体是基本设置，非粗体是组合）：

1 - 光
2 - 明亮
3 - 明亮，明亮
4 - 深色
5 - 浅色，深色
6 - 明亮，深色
7 - 亮，亮，暗