2017 程序设计实习之C++部分作业题汇总 - G：STL 函数对象

题目来源：2017 程序设计实习之C++部分作业题汇总

1、G01:白给的list排序

总时间限制: 1000ms 内存限制: 65536kB
描述
程序填空，产生指定输出

#include 
#include 
#include 
#include 
using namespace std;
int main()
{   
    double a[] = {1.2,3.4,9.8,7.3,2.6};
    list<double> lst(a,a+5);
    //list是双向链表，不支持sort函数，将sort的功能作为方法集成在类的方法中
    //list容器的sort成员函数能将元素从小到大排序，有两个版本
    //1.没有参数。list.sort()，比较大小用<
    //2.函数模板，允许自定义比较大小的规则，op(x,y)为true即认为x
    //template
    //void sort(Pred op)
    //这里需要greater函数模板
    lst.sort(greater<double>()
// 在此处补充你的代码
// 补全sort的比较器op，这里使用在functional中定义的STL函数对象类模板greater
// 在使用greater模板时，要确保>是有定义的，或者是经过了适当的重载
// 在此结束补充的代码
);

    for(list<double>::iterator i  = lst.begin(); i != lst.end(); ++i) 
        cout << * i << "," ;
    return 0;
}

输入
无
输出
9.8,7.3,3.4,2.6,1.2,
样例输入
无
样例输出
同输入
来源
Guo Wei

2、G02:按距离排序

总时间限制: 1000ms 内存限制: 65536kB
描述
程序填空，输出指定结果

#include 
#include 
#include 
#include 
using namespace std;

template <class T1,class T2>
struct Closer {
// 在此处补充你的代码
private:
    T1 val;
    T2 op;
public:
    Closer(const T1 & val_t1,T2 & op_t2):val(val_t1),op(op_t2){}
    //函数对象所在的内，必须重载()，参数的类型与个数不限
    bool operator()(const T1 & x,const T1 & y)
    {
        if (op(val, x) < op(val, y)
            || (op(val, x) == op(val, y)) && x < y)
            return true;
        return false;
    }
// 在此结束补充的代码
};

int Distance1(int n1,int n2) {
    return abs(n1-n2);
}
int Distance2(const string & s1, const string & s2)
{
    return abs((int)s1.length()- (int) s2.length());
}
int a[10] = { 0,3,1,4,7,9,20,8,10,15};
string b[6] = {"American","Jack","To","Peking","abcdefghijklmnop","123456789"};
int main()
{
    //分析main函数的执行过程
    //sort(a,a+10,Closer (n,Distance1))
    //sort(b,b+6,Closer (s,Distance2))
    //Closer的2个类型参数设定为T1,T2,T2是函数指针类型
    //Closer需要有参构造函数
    int n;string s;
    while( cin >> n >> s ) {
        sort(a,a+10,Closer<int ,int (*)(int ,int)> (n,Distance1));
        for(int i = 0;i < 10; ++i)
            cout << a[i] << "," ;
        cout << endl;
        sort(b,b+6,Closer<string,int (*)(const string &,const string &  )> (s,Distance2)); 
        for(int i = 0;i < 6; ++i)
            cout << b[i] << "," ;
        cout << endl;
    }
    return 0;
}

输入
多组数据，每组一行，是一个整数n和一个字符串s
输出
定义两个整数的距离为两个整数差的绝对值
定义两个字符串的距离为两个字符串长度差的绝对值

对每组数据：
对数组a按和n的距离从小到大排序后输出。距离相同的，值小的排在前面。
然后对数组b，按照和s的距离从小到大输出。距离相同的，字典序小的排在前面
样例输入
2 a123456
4 a12345
样例输出
1,3,0,4,7,8,9,10,15,20,
American,Peking,123456789,Jack,To,abcdefghijklmnop,
4,3,1,7,0,8,9,10,15,20,
Peking,American,Jack,123456789,To,abcdefghijklmnop,
来源
Guo Wei

3、G03:goodcopy

总时间限制: 1000ms 内存限制: 65536kB
描述
编写GoodCopy类模板，使得程序按指定方式输出

#include 
using namespace std;

template <class T>
struct GoodCopy {
// 在此处补充你的代码
// 不提供cstring，考虑到GoodCopy()(a,a+m,a+m/2)这种形式
// 模拟三变量交换法，申请一块临时空间存储，用完再释放
private:
    T * ptr;
public:
    void operator()(T * b,T * e,T * new_b)
    {
        int len = e - b;
        ptr = new T[len + 1];
        for(int i = 0;ifor(int i = 0;idelete []ptr;           
    }
// 在此结束补充的代码
};

int a[200];
int b[200];
string c[200];
string d[200];

template <class T>
void Print(T s,T e) {
    for(; s != e; ++s)
        cout << * s << ",";
    cout << endl;
}

int main()
{
    int t;
    cin >> t;
    while( t -- ) {
        int m ;
        cin >> m;
        for(int i = 0;i < m; ++i)
            cin >> a[i];
        GoodCopy<int>()(a,a+m,b);
        Print(b,b+m);
        GoodCopy<int>()(a,a+m,a+m/2);
        Print(a+m/2,a+m/2 + m);

        for(int i = 0;i < m; ++i)
            cin >> c[i];
        GoodCopy<string>()(c,c+m,d);
        Print(c,c+m);
        GoodCopy<string>()(c,c+m,c+m/2);
        Print(c+m/2,c+m/2 + m);
    }
    return 0;
}

输入
第一行是整数 t,表示数据组数
每组数据：
第一行是整数 n , n < 50
第二行是 n 个整数
第三行是 n 个字符串
输出
将输入的整数原序输出两次，用”,”分隔
然后将输入的字符串原序输出两次，也用 “,”分隔
样例输入
2
4
1 2 3 4
Tom Jack Marry Peking
1
0
Ted
样例输出
1,2,3,4,
1,2,3,4,
Tom,Jack,Marry,Peking,
Tom,Jack,Marry,Peking,
0,
0,
Ted,
Ted,
来源
Guo Wei

4、G04:函数对象的过滤器

总时间限制: 1000ms 内存限制: 65536kB
描述
程序填空输出指定结果

#include 
#include 
using namespace std;


struct A {
    int v;
    A() { }
    A(int n):v(n) { };
    bool operator<(const A & a) const {
        return v < a.v;
    }
};
// 在此处补充你的代码
// Filter(ia.begin(),ia.end(),ib.begin(),FilterClass(m,n))
// Filter(aa.begin(),aa.end(),ab.begin(),FilterClass(m,n))
// 对Filter来说，最后一个参数FilterClass(m,n)是一个函数对象
template<class T>
struct FilterClass
{
    T low;
    T high;
    FilterClass(int m,int n):low(m),high(n){}
    bool operator()(const T & rhs)
    {
        if( low < rhs && rhs < high)
            return true;
        return false;
    }
};
// 在此结束补充的代码
template <class T>
void Print(T s,T e)
{
    for(;s!=e; ++s)
        cout << *s << ",";
    cout << endl;
}
template <class T1, class T2,class T3>
T2 Filter( T1 s,T1 e, T2 s2, T3 op) 
{
    for(;s != e; ++s) {
        if( op(*s)) {
            * s2 = * s;
            ++s2;
        }
    }
    return s2;
}

ostream & operator <<(ostream & o,A & a)
{
    o << a.v;
    return o;
}
vector<int> ia;
vector aa; 
int main()
{
    int m,n;
    while(cin >> m >> n) {
        ia.clear();
        aa.clear(); 
        int k,tmp;
        cin >> k;
        for(int i = 0;i < k; ++i) {
            cin >> tmp; 
            ia.push_back(tmp);
            aa.push_back(tmp); 
        }
        vector<int> ib(k);
        vector ab(k);
        vector<int>::iterator p =  Filter(ia.begin(),ia.end(),ib.begin(),FilterClass<int>(m,n));
        Print(ib.begin(),p);
        vector::iterator pp = Filter(aa.begin(),aa.end(),ab.begin(),FilterClass(m,n));
        Print(ab.begin(),pp);

    }
    return 0;
}

输入
多组数据
每组数据两行

第一行是两个整数 m 和 n
第二行先是一个整数k ,然后后面跟着k个整数
输出
对每组数据，按原顺序输出第二行的后k个整数中，大于m且小于n的数
输出两遍
数据保证一定能找到符合要求的整数
样例输入
1 3
1 2
2 8
5 1 2 3 4 9
样例输出
2,
2,
3,4,
3,4,
来源
Guo Wei

5、G05:很难蒙混过关的CArray3d三维数组模板类

总时间限制: 1000ms 内存限制: 65536kB
描述
实现一个三维数组模版CArray3D，可以用来生成元素为任意类型变量的三维数组，输出指定结果
NOTE：此题一开始我设想按照实际的三维数组开一段连续的空间存储，实现上绕不过第一个[]，后来参考了某位大神在程序设计实习实验班2017作业里面具体实现的思路，凭借他的思路解决

#include 
#include  
#include 
using namespace std;
template <class T>
class CArray3D
{
// 在此处补充你的代码
public:
    class CArray2D
    {
    private:
        int row;
        int col;
        int size_;
        T *ptr;
    public:
        CArray2D() :row(0), col(0), size_(0)
        {
            ptr = new T[1];
        }
        void init(int r, int c) 
        {
            row = r; col = c; size_ = r * c;
            delete[]ptr;
            ptr = new T[size_ + 1];
        }
        T * operator[](int i)
        {
            return (ptr + i * col);
        }
        operator T*()//only for memset
        {
            return ptr;
        }
    };
    CArray2D * a;
    CArray3D(int level,int row,int col)
    {
        a = new CArray2D[level];
        //这里还是使用无参构造函数的好
        //真正初始化的工作可以在另外的函数体内完成
        for (int i = 0; i < level; ++i)
            a[i].init(row, col);
    }
    CArray2D& operator[](int i)
    {
        //a由于牵扯到赋值和内部类的复制构造函数，返回值类型设定为&是最好的
        return a[i];
    }
// 在此结束补充的代码
};

CArray3D<int> a(3,4,5);
CArray3D<double> b(3,2,2);
void PrintA()
{
    for(int i = 0;i < 3; ++i) {
        cout << "layer " << i << ":" << endl;
        for(int j = 0; j < 4; ++j) {
            for(int k = 0; k < 5; ++k) 
                cout << a[i][j][k] << "," ;
            cout << endl;
        }
    }
}
void PrintB()
{
    for(int i = 0;i < 3; ++i) {
        cout << "layer " << i << ":" << endl;
        for(int j = 0; j < 2; ++j) {
            for(int k = 0; k < 2; ++k) 
                cout << b[i][j][k] << "," ;
            cout << endl;
        }
    }
}

int main()
{

    int No = 0;
    for( int i = 0; i < 3; ++ i ) {
        a[i];
        for( int j = 0; j < 4; ++j ) {
            a[j][i];
            for( int k = 0; k < 5; ++k )
                a[i][j][k] = No ++;
            a[j][i][i]; 
        }
    }
    PrintA();
    memset(a[1],-1 ,20*sizeof(int));    
    memset(a[1],-1 ,20*sizeof(int));
    PrintA(); 
    //这个是内置类型，就不用处理了
    memset(a[1][1],0 ,5*sizeof(int));   
    PrintA();

    for( int i = 0; i < 3; ++ i )
        for( int j = 0; j < 2; ++j )
            for( int k = 0; k < 2; ++k )
                b[i][j][k] = 10.0/(i+j+k+1);
    PrintB();
    int n = a[0][1][2];
    double f = b[0][1][1];
    cout << "****" << endl;
    cout << n << "," << f << endl;

    return 0;
}

输入
无
输出
等同于样例
样例输入
无
样例输出
layer 0:
0,1,2,3,4,
5,6,7,8,9,
10,11,12,13,14,
15,16,17,18,19,
layer 1:
20,21,22,23,24,
25,26,27,28,29,
30,31,32,33,34,
35,36,37,38,39,
layer 2:
40,41,42,43,44,
45,46,47,48,49,
50,51,52,53,54,
55,56,57,58,59,
layer 0:
0,1,2,3,4,
5,6,7,8,9,
10,11,12,13,14,
15,16,17,18,19,
layer 1:
-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,
layer 2:
40,41,42,43,44,
45,46,47,48,49,
50,51,52,53,54,
55,56,57,58,59,
layer 0:
0,1,2,3,4,
5,6,7,8,9,
10,11,12,13,14,
15,16,17,18,19,
layer 1:
-1,-1,-1,-1,-1,
0,0,0,0,0,
-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,
layer 2:
40,41,42,43,44,
45,46,47,48,49,
50,51,52,53,54,
55,56,57,58,59,
layer 0:
10,5,
5,3.33333,
layer 1:
5,3.33333,
3.33333,2.5,
layer 2:
3.33333,2.5,
2.5,2,

---

7,3.33333
提示
建议做法：
1. a[i][j][k] 这个表达式的第一个[]返回一个内部类的对象，该内部类也重载了[],且返回值为指针。
2. 必要时需重载对象到指针的强制类型转换运算符
来源
Guo Wei

6、G06:我自己的 ostream_iterator

总时间限制: 1000ms 内存限制: 65536kB
描述
程序填空输出指定结果

#include 
#include 
#include 
using namespace std;

template <class T1,class T2>
void Copy(T1 s,T1 e, T2 x)
{
    for(; s != e; ++s,++x)
        *x = *s;
}


template<class T>
class myostream_iteraotr
{
// 在此处补充你的代码
private:
    string s_;
    ostream & os_;
    T val;
public:
    myostream_iteraotr(ostream & os, const string &s) :os_(os), s_(s) {}
    //这个题目的难点在于前置++的返回值应该还是本类的对象上，是与逻辑相一致的思路
    //具体的输出放在++x还是*x内实现都可以
    //在具体的考虑中，*x具体要接收值，++x的功能相对较少
    //也可以考虑用T *类型的指针，相对复杂一些
    myostream_iteraotr& operator++()
    {
        os_ << val << s_;
        return *this;
    }
    T & operator*()
    {
        return val;
    }
// 在此结束补充的代码
};


int main()
{   const int SIZE = 5;
    int a[SIZE] = {5,21,14,2,3};
    double b[SIZE] = { 1.4, 5.56,3.2,98.3,3.3};
    list<int> lst(a,a+SIZE);
    myostream_iteraotr<int> output(cout,",");
    Copy( lst.begin(),lst.end(),output); 
    cout << endl;
    myostream_iteraotr<double> output2(cout,"--");
    Copy(b,b+SIZE,output2);
    return 0;
}

输入
无
输出
5,21,14,2,3,
1.4–5.56–3.2–98.3–3.3–
样例输入
无
样例输出
同输入
来源
Guo Wei