封装的意义

封装的意义

前面《组合序列、排列序列的生成实现》中，我们在最后讨论了如何对组合序列生成函数、排列序列生成函数进行封装，组合序列生成函数定义如下：

void comb(const vector<int>& arr, int beg, int m, vector<vector<int> >& coms, vector<int>& tmp, int& total)
{
    if (m > arr.size() - beg)
    {
        return;
    }
    if (m == 0)
    {
        coms.push_back(tmp);
        ++total;
    }
    else
    {
        tmp.push_back(arr[beg]);
        comb(arr, beg+1, m-1, coms, tmp, total);
        tmp.pop_back();
        
        comb(arr, beg+1, m, coms, tmp, total);
    }
}

          组合函数调用如下：

　　　　　　　　　　　　　　　　　　　　　　　　　　comb(arr, 0, 4, coms, tmp, total);

根据定义和调用，我们发现组合函数定义中，第二个参数int beg只有在定义的时候才能用到，以方便其自身的调用，而对于实际调用没有任何作用，只要是对comb调用，beg的值都要为0。

所以，我们对comb函数封装如下：

// 封装组合
void comb_pack(const vector<int>& arr, int m, vector<vector<int> >& coms, vector<int>& tmp, int& total)
{
    coms.clear();
    tmp.clear();
    total = 0;
    comb(arr, 0, m, coms, tmp, total);
}

         我们对封装后的函数comb_pack调用如下：

　　　　　　　　　　　　　　　　　　　　　　　　comb_pack(arr, 4, coms, tmp, total);

         同样地，我们对排列序列生成函数进行封装。

void
perm(
  const vector<int>& arr_
, int n
, int beg
, vector<vector<int> >& pers
, vector<int>& tmp
, int& total
)
{
    static vector<int> arr(arr_);
    if (n == 0)
    {
        pers.push_back(tmp);
        ++total;
    }
    for (int i = beg; i != arr.size(); ++i)
    {
        exchange(arr[beg], arr[i]);
        tmp.push_back(arr[beg]);
        perm(arr, n-1, beg+1, pers, tmp, total);
        tmp.pop_back();
        exchange(arr[beg], arr[i]);
    }
}

         之前的调用形式为：

　　　　　　　　　　　　　　　　　　　　　　　　perm(arr, 3, 0, perm, tmp, total);

         对perm函数进行封装如下：

// 排列封装
void perm_pack(const vector<int>& arr, int n, vector<vector<> >& pers, vector<int>& tmp, int& total)
{
    pers.clear();
    tmp.clear();
    total = 0;
    perm(arr, n, 0, pers, tmp, total);
}

         对封装函数perm_pack的调用如下：

　　　　　　　　　　　　　　　　　　　　　　　　perm_pack(arr, 3, pers, tmp, total);

         全排列函数的封装如下：

// 全排列封装
void perm_full_pack(const vector<int>& arr, vector<vector<> >& pers, vector<int>& tmp, int& total)
{
    pers.clear();
    tmp.clear();
    total = 0;
    perm(arr, arr.size(), 0, pers, tmp, total);
}

         全排列封装函数的调用为：

　　　　　　　　　　　　　　　　　　　　　　　　perm_full_pack(arr, pers, tmp, total);

         我们可以从对组合序列和排列序列的生成函数进行封装，可以看到封装后的函数少了一些不必要的参数，使得函数更为简介明了，并且在使用的时候避免犯传参方面的错误。

         被封装的函数由于需要对其自身的调用，所以需要一些参数记录其递归层次。通过一步的封装，使得我们的函数把不需要的参数隐蔽起来，这样代码看起来更为友好。

         封装可以使得函数接口更为简约，通过添加一个封装层使得定义层与调用层隔离，降低定义与调用之间的耦合性，提高定义和调用模板各自的内聚性。