泛型编程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/// 交换两个值
/// 给定了交换值的类型，如果需要交换别的类型的值，则需要另一个函数
/// \param x 传入参数指针
/// \param y 传入参数指针
void SwapInt(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

/// 交换两个值
/// 使用 void * 代替普通类型
/// 由于使用void * ，编译器不能通过类型得到类型的尺寸，添加 size 参数表示类型的长度
/// \param x 传入参数指针
/// \param y 传入参数指针
/// \param size 传入指针大小
void SwapVoid(void *x, void *y, size_t size) {
    char tmp[size];
    memcpy(tmp, y, size);
    memcpy(y, x, size);
    memcpy(x, tmp, size);
}

/**
 * 交换两个值，宏定义模式
 * 宏定义的方式有个弊端，在使用宏定义时，由于宏替换的缘故，会导致传入的参数发生改变
 * 例如：
 *
 * #define min(x, y)  ((x)>(y) ? (y) : (x))
 *
 * 在使用此宏时  int k = min(i++, j++);
 * 由于宏替换的缘故，相当于执行了
 *
 * (i++) > (j++) ? (j++) : (i++)
 *
 * x 或 y 的值会被累加两次
 * */
#define swap(x, y, size) {\
    char temp[size]; \
    memcpy(temp, &y, size); \
    memcpy(&y,   &x, size); \
    memcpy(&x, temp, size); \
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

/// 在int 指针对象中搜索目标出现的位置，在此版本中传入对象的类型一定，目标一定
/// \param a 传入对象
/// \param size 对象长度
/// \param target 目标
/// \return 目标所在位置
int SearchNormal(int *a, size_t size, int target) {
    for (int i = 0; i < size; i++) {
        if (a[i] == target) {
            return i;
        }
    }
}

/// 查找泛型函数
/// - 输入对象任意
/// - 偏移依靠元素 size * i 实现
/// - 对比函数由外界提供
/// \param a 传入对象
/// \param size 传入对象长度
/// \param target 目标
/// \param elem_size 传入对象元素大小
/// \param cmpFn 对比函数
/// \return 目标所在位置
int SearchParadigm(void *a, size_t size, void* target, size_t elem_size, int(*cmpFn)(void*, void*)){
    for (int i = 0; i < size; i++) {
        if(cmpFn((unsigned char *)a + elem_size * i, target) == 0){
            return i;
        }
    }
}

/// int 类型比较操作
/// \param x 待比较的参数1
/// \param y 待比较的参数2
/// \return 比较结果， 0为相等
int int_cmp(int *x, int *y) {
    return *x - *y;
}

/// char 类型比较操作
/// \param x 待比较的参数1
/// \param y 待比较的参数2
/// \return 比较结果， 0为相等
int string_cmp(char *x, char *y) {
    return strcmp(x, y);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

template<class Iter, class T, class Op>
T reduce(Iter start, Iter end, T init, Op op) {
    T result = init;
    for (; start != end; start++) {
        result = op(result, *start);
    }
    return result;
}

struct Employee {
    string name;
    string id;
    int vacation;
    double salary;
};

template<class T, class Cond>
struct counter {
    Cond cond;
    size_t operator()(size_t c, T t) {
        return c + (cond(t) ? 1 : 0);
    }
};


template<class Iter, class Cond>
size_t count_if(Iter begin, Iter end, Cond c) {
    auto op = counter<typename Iter::value_type, Cond>{c};
    return reduce(begin, end, size_t(0), op);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

vector<Employee> v_employee;
Employee employee_001 = {"Tom", "001", 10, 10000.0};
v_employee.push_back(employee_001);
Employee employee_002 = {"John", "002", 7, 220.0};
v_employee.push_back(employee_002);
Employee employee_003 = {"Alfons", "003", 6, 9000.0};
v_employee.push_back(employee_003);
Employee employee_004 = {"Mich", "004", 1, 101000.0};
v_employee.push_back(employee_004);

double sum_salaries = reduce(v_employee.begin(), v_employee.end(), 0.0,
                            [](double s, Employee e) -> double { return s + e.salary; });