日志二

一、gdb编译方式

与编译单个文件类似，只需将多个文件同时包含进去，以g++执行命令为例:
g++ -o codefile main.cpp student.cpp
运行命令：
./codefile

• 当然这种方式不便于程序的动态维护，每次修改当个源程序都要重新编译整个代码文件，因此只适用于编译少量文件

二、Make编译方式

pass

三、GDB调试

3.1 gdb执行命令

本文调试以双端队列.exe可执行文件为例进行gdb代码调试
此处应注意在编译源文件时一定要加上-g选项，以便能够正常调试程序
最简单的一种执行命令： gdb 程序名
启动调试程序: gdb 双端队列，执行成功后gdb界面如下：

<1> 代码查看命令 list及相关操作

<2> 程序运行命令

运行程序命令：r 即可运行整个程序
程序退出命令：q 即可中断退出程序
继续执行命令：c 即continue,表示程序在遇到断点后停止再继续运行时的命令

<3> 命令行参数

当需要对程序通过命令行传入参数时，在gdb中需要另外指定传入的参数，执行命令为 :
set args 参数一 参数二
在此运行 r 命令，即可启动程序

3.2 gdb断点管理

<1> 设置断点

普通断点

设置普通断点通常有两种方式，第一种针对单个源程序，其命令为
b 行号 # break 简写为b, 当然break也可以
第二种方式针对指定文件设置断点，其命令为
b 双端队列.cpp:行号
再次运行程序便会在指定断点处停止执行，此时可以查看断点附近代码
执行命令 l,便会显示在断点前后五行的代码
查看变量的值其命令为
print 变量 # print可简写为p

函数断点

注：其实函数断点也是普通断点的一种，主要是考虑在执行功能上两者又有很大区别，所以本文对两者进行非类探讨
函数断点设置语法：break 函数名
说明，在处理多个同名但是参数不同的函数时，gdb会为所有同名函数都设置断点，因为这样不论调用哪个函数，都会被中断。
指定特定同名函数设置断点
当然如果不想对所有同名函数都设置断点，而只针对某一个函数设置断点，可以通过指定函数，具体命令如下:
b test_1::test_fun
b test_fun(int)
第一种是在类里面的指定函数，第二种通过区分参数类型来判断特定函数
本文所用调试代码

#include<iostream>
#include<cstdlib>
#include<random>
#include<ctime>
const int Nnum = 999;
using namespace std;
/*----------双端队列(Deque)-------/
/*-------变式——输出受限或输入受限的双端队列：限制其中一个端点的插入或删除操作-----
----------(此类形式不作赘述)-------*/
/*限定插入和删除操作只能在端点处进行*/
typedef struct Qnode {
    int data;
    struct Qnode* next;
}Qnode, * QuePtr;
typedef struct {
    QuePtr front; // 队列头指针
    QuePtr rear;   // 队列尾指针
}LinkQue;
// 对应相关操作
bool InitQueue(LinkQue& Q);
bool Push_Front(LinkQue& Q, int e);
bool Push_Back(LinkQue& Q, int e);
int Pop_Front(LinkQue& Q);
int Pop_Back(LinkQue& Q);
bool ClearQueue(LinkQue& Q);
int QueueLength(LinkQue Q);
int GetHead(LinkQue Q);
int GetRear(LinkQue Q);
bool QueuePrint(LinkQue Q);

int main()
{
    srand(time(NULL));//设置随机数种子，使每次产生的随机序列不同
    int N = 30;
    // 创建一个双端队列
    LinkQue Q;
    if (!InitQueue(Q)) return 0;
    for (int i = 0; i < N; i++) {
        if (rand() % (Nnum + 1) / (float)(Nnum + 1) < 0.5) Push_Back(Q, i + 1);
        else Push_Front(Q, i + 1);
    }
    QueuePrint(Q);
    for (int i = 0; i < N / 2; i++) {
        if (rand() % (Nnum + 1) / (float)(Nnum + 1) < 0.5) {
            int e = Pop_Back(Q);
            if (e == -1) continue;
            else cout << "Pop element back: " << e << endl;
        }
        else {
            int e = Pop_Front(Q);
            if (e == -1) continue;
            else cout << "Pop element head: " << e << endl;
        }
    }
    QueuePrint(Q);
    return 0;
}
// 初始化队列的生成
bool InitQueue(LinkQue& ptr)
{
    ptr.front = (QuePtr)malloc(sizeof(Qnode));
    if (!ptr.front) return false;
    ptr.rear = ptr.front;
    ptr.front->data = 0;
    ptr.front->next = NULL;
    return true;
}
/*----------------------------------------*/
// 元素队首入队列
bool Push_Front(LinkQue& Q, int e)
{
    QuePtr p = (QuePtr)malloc(sizeof(Qnode));
    if (!p) return false;
    p->data = e;
    p->next = Q.front->next;
    Q.front->next = p;
    Q.front->data++;   //更新队列长度
    if (Q.front == Q.rear) Q.rear = p;  // 特判初始状态
    return true;
}
// 元素队尾入队列
bool Push_Back(LinkQue& Q, int e)
{
    QuePtr p = (QuePtr)malloc(sizeof(Qnode));
    if (!p) return false;
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    Q.front->data++;   //更新队列长度
    return true;
}
/*------------------------------------*/
/*------------------------------------*/
int Pop_Front(LinkQue& Q)
{
    //首先判断队列是否为空
    if (Q.front == Q.rear) return -1;
    QuePtr p = Q.front->next;
    int e = p->data;
    Q.front->next = p->next;
    // 对最后一个元素进行特判
    if (Q.rear == p) Q.rear = Q.front;
    free(p);
    Q.front->data--;
    return e;
}
int Pop_Back(LinkQue& Q)
{
    //首先判断队列是否为空
    if (Q.front == Q.rear) return -1;
    QuePtr p = Q.front;
    while (p->next != Q.rear) p = p->next;
    int e = Q.rear->data;
    free(Q.rear);
    p->next = NULL;
    Q.rear = p;
    Q.front->data--;
    return e;
}
/*----------------------------------*/
bool ClearQueue(LinkQue& Q)
{
    QuePtr p = Q.front->next;
    while (p) {
        p->data = 0;
        p = p->next;
    }
    return true;
}
int QueueLength(LinkQue Q)
{
    return Q.front->data;
}
int GetHead(LinkQue Q)
{
    return Q.front->next->data;
}
int GetRear(LinkQue Q)
{
    return Q.rear->data;
}
bool QueuePrint(LinkQue Q)
{
    QuePtr p = Q.front->next;
    if (!p) {
        cout << "Empty Queue！" << endl;
        return true;
    }
    cout << "The length of deque: " << QueueLength(Q) << endl;
    cout << "Deque head element: " << GetHead(Q) << ' ' << "Deque end element: " << GetRear(Q) << endl;
    cout << "Deque elements:" << endl;
    while (p) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
    return true;
}