给我上面问题封装好的代码，并且需要有相应的类

好的，以下是我为您封装好的代码，包括了自定义的数据结构和容器类：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 自定义的数据结构，用于存储一个元素及其出现的次数
struct Element {
    int value;  // 元素的值
    int count;  // 元素出现的次数

    Element(int v, int c) : value(v), count(c) {}
};

// 自定义的容器类，用于存储元素及其出现的次数
class ElementList {
public:
    // 向容器中添加一个元素
    void add(int value) {
        // 遍历容器，查找是否已经存在该元素
        for (auto& e : list) {
            if (e.value == value) {
                // 如果存在，则增加其出现的次数
                e.count++;
                return;
            }
        }
        // 如果不存在，则新建一个元素并添加到容器中
        Element e(value, 1);
        list.push_back(e);
    }

    // 获取容器中元素的数量
    int size() const {
        return list.size();
    }

    // 根据索引获取容器中的元素
    Element& operator[](int index) {
        return list[index];
    }

    // 根据索引获取容器中的元素（const 版本）
    const Element& operator[](int index) const {
        return list[index];
    }

private:
    vector<Element> list;  // 存储元素及其出现的次数
};

// 自定义的组合结果类，用于存储一个组合及其出现的次数
class Combination {
public:
    // 添加一个元素到组合中
    void add(int value) {
        // 将该元素添加到当前组合中
        current.push_back(value);
        // 计算当前组合的总和
        sum += value;
        // 如果当前组合的总和等于目标数，则将当前组合加入结果列表中
        if (sum == target) {
            result.add(current);
        }
        // 如果当前组合的总和小于目标数，则继续向其中添加元素
        else if (sum < target) {
            // 从当前索引开始遍历元素
            for (int i = index; i < elements.size(); i++) {
                // 如果该元素的出现次数大于 0，且加上该元素后不会超过目标数，则将该元素添加到当前组合中
                if (elements[i].count > 0 && sum + elements[i].value <= target) {
                    elements[i].count--;  // 减少该元素的出现次数
                    index = i;  // 更新当前元素的索引
                    add(elements[i].value);  // 递归调用添加元素
                    elements[i].count++;  // 恢复该元素的出现次数
                }
            }
        }
        // 将刚添加的元素从当前组合中删除，并更新组合的总和
        current.pop_back();
        sum -= value;
    }

    // 设置候选元素数组及目标数，并初始化组合结果列表
    void set(const vector<int>& nums, int target) {
        this->target = target;
        index = 0;
        sum = 0;
        current.clear();
        result.clear();
        elements = ElementList();
        // 将候选元素数组中的元素添加到元素列表中
        for (auto num : nums) {
            elements.add(num);
        }
        // 对元素列表进行排序，方便后面的去重和剪枝操作
        sort(elements[0], elements[size()], [](const Element& e1, const Element& e2) {
            return e1.value < e2.value;
        });
    }

    // 获取组合结果列表中的元素数量
    int size() const {
        return result.size();
    }

    // 根据索引获取组合结果列表中的元素
    vector<int>& operator[](int index) {
        return result[index];
    }

private:
    ElementList elements;  // 存储候选元素及其出现的次数
    int target;  // 目标数
    int index;  // 当前元素的索引
    int sum;  // 当前组合的总和
    vector<int> current;  // 当前组合
    vector<vector<int>> result;  // 组合结果列表
};

// 主函数
int main() {
    int n;
    while (cin >> n && n > 0) {
        vector<int> nums(n);
        for (int i = 0; i < n; i++) {
            cin >> nums[i];
        }
        int target;
        cin >> target;

        // 创建 Combination 类对象并调用 set 方法设置候选元素数组及目标数
        Combination c;
        c.set(nums, target);

        // 遍历组合结果列表，按照要求输出结果
        for (int i = 0; i < c.size(); i++) {
            cout << i + 1 << ":";
            for (int j = 0; j < c[i].size(); j++) {
                if (j > 0) {
                    cout << ";";
                }
                for (int k = 0; k < c[i][j]; k++) {
                    cout << " " << c[i][j];
                }
            }
            cout << endl;
        }
    }

    return 0;
}

在这个封装的代码中，我定义了一个 `Element` 结构体，用于存储一个元素及其出现的次数，还定义了一个 `ElementList` 类，用于存储元素及其出现的次数，并提供了添加元素、获取元素数量、根据索引获取元素等基本方法。

同时，我还定义了一个 `Combination` 类，用于计算所有可以使数字和为目标数的不同组合。该类中包括了一个 `ElementList` 类型的成员变量 `elements`，用于存储候选元素及其出现的次数；一个整型成员变量 `target`，用于存储目标数；一个整型成员变量 `index`，用于存储当前元素在候选元素数组中的索引；一个整型成员变量 `sum`，用于存储当前组合的总和；一个 `vector<int>` 类型的成员变量 `current`，用于存储当前组合；一个 `vector<vector<int>>` 类型的成员变量 `result`，用于存储所有可以使数字和为目标数的不同组合。该类中还包括了一些基本方法，如 `add` 方法用于向当前组合中添加元素，`set` 方法用于设置候选元素数组及目标数，`size` 方法用于获取组合结果列表中的元素数量，`operator[]` 方法用于根据索引获取组合结果列表中的元素。