【 C++ 】 讲解与实现 对数器接口

什么是对数器

说是叫对数器，但我觉得叫做核验器更好。
为什么？因为其作用是核验算法是否正确，所以我觉得叫核验器更好。
注意：本文实现的是生成只能int类型的对数器，其余类型不支持。

对数器的原理

对于一个核验器，其作用就是生成大量的数据来轰炸算法，若是算法经受了大量数据的轰炸，且保证每次都可以返回一个正确的值，说明这个算法是健壮的，良好的。

实现思路

1. 对数器会不断的生成随机大小、随机内容的数组；
2. 复制一份相同的数组；
3. 把两个数组分别传入自己写的算法代码，以及传入专业的代码中；
4. 对比两份代码输出的结果，结果不一样则退出；
5. 结果一样就回到第1步。

代码实现

核心代码

#include <iostream>
#include <ctime>
#include <random>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;

// 生成一个随机长度的内容随机数组
void Generator(int*& arr, int size, int val, int& len)
{
    static int i = 0;
    default_random_engine e;
    uniform_int_distribution<int> u1(0, size); // 左闭右闭区间
    uniform_int_distribution<int> u2(0, val); // 左闭右闭区间
    e.seed(time(0) + (i++));

	// 生成随机长度
    len = u1(e);

    arr = new int[len];

    for (int i=0; i < len; i++)
    {
    	// 生成随机数据
        arr[i] = u2(e);
    }
}

// 生成随机带大小，随机数据的数组，给到两个外部传入的数组
void GenerateRandomArr(int*& arr1, int*& arr2, int& len)
{
    len = 0;
    Generator(arr1, 100, 100, len);
    arr2 = new int[len];
    memcpy(arr2, arr1, sizeof(int)*len);
}

// 删除动态创建的数组
void deleteArr(int*& arr)
{
    delete arr;
    arr = nullptr;
}

// 对比标准的算法，和自己编写的算法的区别
int Verifier(int NumberTest, int (*testFun)(int*& , int*& , int&))
{
    int len = 0;
    int* arr1 = NULL;
    int* arr2 = NULL;
    int err = 0;

    for (int i = 0; i < NumberTest; i++)
    {
        // 生成部分
        GenerateRandomArr(arr1, arr2, len);

        // 运算与数据对比
        testFun(arr1, arr2, len);

        // 收尾
        deleteArr(arr1);
        deleteArr(arr2);
        if( err != 0 )
        {
            return 1;
        }
    }
    
    return 0;
}

测试代码

这里实现了一个快速排序，然后调用了库的排序代码进行对比测试。

#include <iostream>
#include <ctime>
#include <random>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;

// 快速排序
void quickSort(int* pArr, int len)
{
    int* i = pArr;
    int* j = (pArr+len-1);
    int* p = pArr;

    while ( j > i )
    {
        while ( i != p && *i <= *p )
        {
            i++;
        }
        if ( i != p )
        {
            *i ^= *p;
            *p ^= *i;
            *i ^= *p;

            p = i;
        }

        while ( j != p && *p <= *j )
        {
            j--;
        }
        if ( j != p )
        {
            *j ^= *p;
            *p ^= *j;
            *j ^= *p;

            p = j;
        }
    }

    // 左边存在超过一个值
    if( p-pArr > 1 )
    {
        quickSort(pArr, p-pArr);
    }
    // 右边存在超过一个值
    if( len - (p-pArr) - 1 > 1 )
    {
        quickSort(p+1, len - (p-pArr) - 1);
    }
}

// 给对数器传入的运算与数据对比的函数
int sortVerifier(int*& arr1, int*& arr2, int& len)
{
    int err = 0;

	 // 打印数据
	 for(int i=0; i<len; i++)
	 {
	 	cout << arr1[i] << endl;
	 }
	 cout << "" << endl;
	 cout << "" << endl;

    // 运算部分
    sort(arr1, arr1+len, less<int>());
    quickSort(arr2, len);

    // 数据对比部分
    err = memcmp(arr1, arr2, sizeof(int)*len);
    
    return err;
}


int main()
{
	// 进行1000次轰炸看看效果
    if( Verifier(1000, sortVerifier) == 0 )
    {
        cout << "ok" << endl;
    }
    else
    {
        cout << "error" << endl;
    }

    system("pause");
    return 0;
}

效果