算法分析工具

算法分析工具可以用于观察数组的变化，变量的计算过程，能够辅助分析排序算法，STL算法，数值算法等

源码下载地址: http://pan.baidu.com/s/1kT9smSf

最后给出了使用手册，并不完整, 具体的细节可以参照源文件中的 "gt.h"， “GuardConfig.h”， "manual.hpp" 

关于数值计算

#include "gt.h"

int main(void)
{
    AddId("id_Pi")("id_r");     // 为后面的变量命名用于跟踪输出到控制台，函数后面可以添加任意个参数
    Double Pi = 3.1415926, r;
    r = 4.1;
    
    AddId("id_perimeter")("id_area");   // 为后面的变量命名用于跟踪输出到控制台
    Double perimeter, area;
    perimeter = 2 * Pi * r;
    area = Pi * pow(r, 2);
    return 0;
}

控制台自动输出

				EXPRES:id_Pi = 3.141593
				EXPRES:id_r = 4.1
				EXPRES:id_perimeter = (2*3.141593)*4.1
				EXPRES:id_area = 3.141593*pow(4.1, 2)

希尔排序代码

#include "gt.h"

const unsigned int N = 4;                       // 下面数组的长度
const unsigned int SellNum[N] = {7, 3, 1};  // 最后一个数值必须是 1

void ShellSort(IntPtr arr, int length) {
    for(int n=0; narr[k]; k-=increase) {
                    int temp = arr[k];
                    arr[k] = arr[k-increase];
                    arr[k-increase] = temp;
                    if(k-2*increase < 0)break;
                }
            }
        }
    }
}

int main(void)
{
    int a[] = {3, 1, 3, 63, 11,2, 5,23, 51};
    IntArr arr(a);
    ShellSort(arr, 9);
    for(int i=0; i<9; i++) {
        printf("%d  ", arr[i]);
    }
    return 0;
}

希尔排序对应控制台的输出

				EXPRES:GT[6] = GT[3]
  3   1   3   63   11   2  [63]  23   51 

				EXPRES:GT[3] = 5
  3   1   3  [5]  11   2   63   23   51 

				EXPRES:GT[5] = GT[2]
  3   1   3   5   11  [3]  63   23   51 

				EXPRES:GT[2] = 2
  3   1  [2]  5   11   3   63   23   51 

				EXPRES:GT[1] = GT[0]
  3  [3]  2   5   11   3   63   23   51 

				EXPRES:GT[0] = 1
 [1]  3   2   5   11   3   63   23   51 

				EXPRES:GT[2] = GT[0]
  1   3  [3]  5   11   3   63   23   51 

				EXPRES:GT[1] = 2
  1  [2]  3   5   11   3   63   23   51 

				EXPRES:GT[5] = GT[4]
  1   2   3   5   11  [11]  63   23   51 

				EXPRES:GT[4] = 3
  1   2   3   5  [3]  11   63   23   51 

				EXPRES:GT[4] = 5
  1   2   3   5  [5]  11   63   23   51 

				EXPRES:GT[3] = 3
  1   2   3  [3]  5   11   63   23   51 

				EXPRES:GT[7] = GT[3]
  1   2   3   3   5   11   63  [63]  51 

				EXPRES:GT[6] = 23
  1   2   3   3   5   11  [23]  63   51 

				EXPRES:GT[8] = GT[3]
  1   2   3   3   5   11   23   63  [63]

				EXPRES:GT[7] = 51
  1   2   3   3   5   11   23  [51]  63 

程序具有许多的可配置项，可以观察各种效果

在 main 添加上一句  

TurnTrace(ON);

之后的希尔排序输出效果

				TRACE: GT[0] > GT[7] = 0
				TRACE: GT[1] > GT[8] = 0
				TRACE: GT[0] > GT[3] = 0
				TRACE: GT[3] > GT[6] = 1
				EXPRES:GT[6] = GT[3]
  3   1   3   63   11   2  [63]  23   51 

				TRACE: GT[3] = 5
				EXPRES:GT[3] = 5
  3   1   3  [5]  11   2   63   23   51 

				TRACE: GT[0] > GT[3] = 0
				TRACE: GT[1] > GT[4] = 0
				TRACE: GT[4] > GT[7] = 0
				TRACE: GT[2] > GT[5] = 1
				EXPRES:GT[5] = GT[2]
  3   1   3   5   11  [3]  63   23   51 

				TRACE: GT[2] = 2
				EXPRES:GT[2] = 2
  3   1  [2]  5   11   3   63   23   51 

				TRACE: GT[5] > GT[8] = 0
				TRACE: GT[0] > GT[1] = 1
				EXPRES:GT[1] = GT[0]
  3  [3]  2   5   11   3   63   23   51 

				TRACE: GT[0] = 1
				EXPRES:GT[0] = 1
 [1]  3   2   5   11   3   63   23   51 

				TRACE: GT[1] > GT[2] = 1
				EXPRES:GT[2] = GT[0]
  1   3  [3]  5   11   3   63   23   51 

				TRACE: GT[1] = 2
				EXPRES:GT[1] = 2
  1  [2]  3   5   11   3   63   23   51 

				TRACE: GT[0] > GT[1] = 0
				TRACE: GT[2] > GT[3] = 0
				TRACE: GT[3] > GT[4] = 0
				TRACE: GT[4] > GT[5] = 1
				EXPRES:GT[5] = GT[4]
  1   2   3   5   11  [11]  63   23   51 

				TRACE: GT[4] = 3
				EXPRES:GT[4] = 3
  1   2   3   5  [3]  11   63   23   51 

				TRACE: GT[3] > GT[4] = 1
				EXPRES:GT[4] = 5
  1   2   3   5  [5]  11   63   23   51 

				TRACE: GT[3] = 3
				EXPRES:GT[3] = 3
  1   2   3  [3]  5   11   63   23   51 

				TRACE: GT[2] > GT[3] = 0
				TRACE: GT[5] > GT[6] = 0
				TRACE: GT[6] > GT[7] = 1
				EXPRES:GT[7] = GT[3]
  1   2   3   3   5   11   63  [63]  51 

				TRACE: GT[6] = 23
				EXPRES:GT[6] = 23
  1   2   3   3   5   11  [23]  63   51 

				TRACE: GT[5] > GT[6] = 0
				TRACE: GT[7] > GT[8] = 1
				EXPRES:GT[8] = GT[3]
  1   2   3   3   5   11   23   63  [63]

				TRACE: GT[7] = 51
				EXPRES:GT[7] = 51
  1   2   3   3   5   11   23  [51]  63 

				TRACE: GT[6] > GT[7] = 0
1  2  3  3  5  11  23  51  63

使用手册

#ifndef MANUAL_HPP
#define MANUAL_HPP
#include 
#include "gt.h"
using namespace std;

/**
 * @brief 算法分析器使用方法
 *
 * 1.将文件解压到工作目录 并在工作文件中 #include "gt.h"
 *
 * 2.修改对应的变量定义 例如： int i; 改成 Int i;
 *
 * 示例如下程序
 *
 * @return
 */



// 函数传递数组的三种方式
// 方式一通过指针传递 IntPtr p 类似于 int * p;
void func(IntPtr p) {
    for(int i=0; i<3; i++)
        p[i] = i;
}

// 通过 C++ 引用传递数组
void func2(IntArr& arr) { // 注意这里的 “&”
    // 这里数组的改变将会被传递到函数外部，就好像是在使用数组指针
    arr[1] = 1;
}


int manual() {
    //－－－－－－－－－－－－－－－－－－常用示例－－－－－－－－－－－－－－－－－－－－－－
    
    Int i("i");                 // 将 int型变量 i 命名为 “i” 用于跟踪输出到控制台
    IntArr a1(5, "a1");         // 定义 int 型一维数组 a1 长度为5 并命名为 “a1” 用于跟踪输出到控制台
    IntArr2 a2(2, 3, "a2");     // 定义 int 型二维数组 a2 第一维长度为2 第二维长度为3  并命名为 “a2” 用于跟踪输出到控制台
    IntArr3 a3(2, 3, 4, "a3");  // 定义 int 型三维数组 a3 第一维长度为2 第二维长度为3 第三维长度为4  并命名为 “a3” 用于跟踪输出到控制台
    // 除了 Int 之外 GT.h 中还定义了 Char, Short, Double, LongDouble, String 等类型 和 对应的数组类型 可以直接用来使用
    
    AddId("id_Pi")("id_r");     // 为后面的变量命名用于跟踪输出到控制台，函数后面可以添加任意个参数
    Double Pi = 3.1415926, r;
    r = 4.1;
    
    AddId("id_perimeter")("id_area");   // 为后面的变量命名用于跟踪输出到控制台
    Double perimeter, area;
    perimeter = 2 * Pi * r;
    area = Pi * pow(r, 2);
    
    a1[i]++;
    a2[1][2] *= i;
    a3[1][2][3] <= i;

    a3[1][1][1] = 1;
    for(int i=0; i<5; i++) {
        a1[i] = 5-i;
    }

    //printf("int ＝ %d\n 请输入下一个数值\n", i);
    //scanf("%d", &i);

    
    int ax[] = {1, 2, 3, 4, 5};
    IntArr arr1(ax);            // 构造一个一维数组 arr1 并且把 ax 全部元素复制到 arr
    
    ax[1] = 1;                  // 这里不会改变 ax 的值
    int ax2[2][2] = {
        {1, 2},
        {3, 4}};
    IntArr2 arr2(ax2);          // 构造一个2*2二维数组 arr2 并且把 ax2 全部元素复制到 arr2
    
    
    
    // －－－－－－－－－－－－－－－－－－指针的用法－－－－－－－－－－－－－－－－－－－－－－－

    IntPtr p = a1;              // 定义 p 为 int 型指针(类似于 int * p;) 并将数组首地址复制给指针
    *(p+1) = 9;                 // 等价于 a1[1] = 9;
    IntPtr2 p2 = a2;            // 定义 p2 为 int 型二级指针(类似于 int ** p;) 并将二维数组首地址复制给指针
    **p2 = 9;                   // 等价于 a2[0][0] = 9;

    

    // －－－－－－－－－－－－－－－－－－C++ 相关－－－－－－－－－－－－－－－－－－－－－－－－

    //GuardConfig::TurnAllGuardOff();             // 关闭所有跟踪

    //GuardConfig::rule["="] = true;              // 开启 “＝” 跟踪，其他符号类似

    //GuardConfig::TurnArrayOutPutSwitch(true);   // 数组元素变化时，输出整个数组
    
    TurnTrace(ON);              // 将 TRACE 输出到控制台
    TurnExpres(ON);             // 将 EXPRES 输出到控制台
    
    Double j = 3;
    j.SetName("j");

    cout << a1;                                 // 输出方式 1

    for(size_t i=0; i(cout, " "));// 输出方式 4

    // 排序
    std::sort(a1.begin(), a1.end());
    
    // 以 0 为初始值 计算累加和
    Int result = accumulate(a1.begin(), a1.end(), 0);
    cout << "accumulate result: " << result << endl;



    // －－－－－－－－－－－－－－－－－－适配自己需要的跟踪类型－－－－－－－－－－－－－－－－－－－

    // 用 MyInt 类型定义数据, 实际操作的数据类型为 int
    // 并且 自动生成了 一维数组 MyIntArr, 二维数组 MyIntArr2, 三维数组 MyIntArr3
    GT_TYPE(int, MyInt);


    // 自定义 GT跟踪类型 需要的构造函数
    class GT : public Double {
    public :
        GT(const std::string& id = "") : Double(id){ }
        const GT& operator = (const double& data) {
            (Double&)*this = data;
            return *this;
        }
    };

    // 自定义 Vec跟踪类型 需要的构造函数
    class Vec : public DoubleArr {
    public :
        Vec(size_t length, const std::string& id = "") :
            DoubleArr(length, id){ }
    };

    // 自定义 Mat跟踪类型 需要的构造函数
    class Mat : public DoubleArr2 {
    public :
        Mat(size_t m, size_t n, const std::string& id = "") :
            DoubleArr2(m, n, id){ }
    };

    // 自定义 Mat3d跟踪类型 需要的构造函数
    class Mat3d : public DoubleArr3 {
    public :
        Mat3d(size_t m, size_t n, size_t k, const std::string& id = "") :
            DoubleArr3(m, n, k, id){ }
    };
    
    return 0;
}

#endif // MANUAL_HPP