正则表达式和异常处理

正则表达式

元字符

.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线或汉字
\s	匹配任意的空白符
\d	匹配数字
\b	匹配单词的开始或结束
^	匹配字符串的开始（在集合字符里[^a]表示非（不匹配）的意思
$	匹配字符串的结束

反义字符

代码/语法	说明
\W	匹配任意不是字母，数字，下划线，汉字的字符
\S	匹配任意不是空白符的字符
\D	匹配任意非数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意字符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

--------------------------------------------------------------------------------------------------------------------------------

System exit(0/非0);

0正常停止

非0异常停止

Alt+Enter编译时期异常处理方法

throw

try{

   可能异常的语句;

   若语句正常，则正常执行该语句

}

catch(异常原因1  变量){

    若异常原因与判断相同，则输出catch里面的语句1

}

catch(异常原因2  变量){

    若异常原因与判断相同，则输出catch里面的语句2

}

finally{

一定会执行的语句

}

注意：如果这些异常原因有父子关系的话，父要写在下面

在jdk7之后，遇到多个问题但是为同一种解决方式的时候，就可以用一个符号隔开

Ctr + Alt +t    快速使用tyr+catch

若上面的表达式中如果语句1和语句2是同一种解决方式，则可简写为：

try{

   可能异常的语句;

   若语句正常，则正常执行该语句

}

catch(异常原因1 | 异常原因2  变量){

    若异常原因与判断相同，则输出catch里面的语句

}

如果异常原因与所判断的原因不相同，那就相当于try...catch语句白写了，还是交给虚拟机进行处理

注意：由于那个代码是从上到下进行执行的，如果在try中有俩个异常语句，第一个异常语句和下面的某个catch语句相匹配了之后，就不会继续判断第二个异常语句

---------------------------

第三钟只是将错误原因打印在控制台，不会停止运行程序

throw和throws

自定义异常

可以用throw抛出异常，然后使用try+catch进行处理

父类的方法没有抛出异常，子类就不能抛出异常

file的三种构造方式

file(String);

file(String,String);

file(file,String);

————————————————————————————————————--

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAXVEX 10

struct EdgeNode
{
    int adjvex;             // 邻接点域，存储该顶点对应的下标
    struct EdgeNode* next;  // 下一个结点
};

struct VertexNode
{
    int in;                 // 入度
    int data;           // 值
    struct EdgeNode* firstedge;  // 邻接表头指针
};

struct Graph
{
    struct VertexNode vers[MAXVEX];
    int numVertexes;  // 顶点数
};

int TopologicalSort(struct Graph* G,int *pq)
{
    struct EdgeNode* e;
    int i, k, gettop;
    int top = 0;  // 栈指针下标
    int count = 0;  // 统计输出顶点个数
    int* stack;  // 存储入度为0的顶点
    int x = G->numVertexes;
    stack = (int*)malloc(G->numVertexes * sizeof(int));

    for (i = 0; i < G->numVertexes; i++)  // 遍历所有结点
        if (G->vers[i].in == 0)
            stack[++top] = i;  // 将入度为0的顶点入栈

    while (top != 0)
    {
        gettop = stack[top--];  // 出栈
        //printf("%d", G->vers[gettop].data);
        pq[G->vers[gettop].data] = x;//便于bool的判断
        x--;
        count++;  // 统计输出顶点数
        for (e = G->vers[gettop].firstedge; e; e = e->next)
        {
            
            k = e->adjvex;
            if (!(--G->vers[k].in))  // 将k号顶点邻接点的入度减1
                stack[++top] = k;  // 若为0则入栈，以便下次循环输出
        }
    }
    if (count < G->numVertexes)  // 如果count小于顶点数，说明存在环
        return 0;
    else
        return 1;
}

void CreateGraph(struct Graph* G)
{
    int i, m, n, numEdges;

    printf("输入顶点数：\n");
    scanf("%d", &G->numVertexes);
    printf("输入边数：\n");
    scanf("%d", &numEdges);
    for (i = 0; i < G->numVertexes; i++)
    {


        G->vers[i].data = i;
    }
    // 初始化图头结点指针和入度值
    for (i = 0; i < G->numVertexes; i++)
    {
        G->vers[i].firstedge = NULL;
        G->vers[i].in = 0;  // 入度为0
    }
    printf("输入边：\n");
    for (i = 0; i < numEdges; i++)
    {
        scanf("%d %d", &m, &n);
        struct EdgeNode* newNode = (struct EdgeNode*)malloc(sizeof(struct EdgeNode));
        newNode->next = G->vers[m].firstedge;
        newNode->adjvex = n;
        G->vers[m].firstedge = newNode;
        G->vers[n].in++;  // 入度+1
    }
}

bool pan(bool *a,int *pq)
{
    printf("输入q的值\n");
    int m,n;int num = 0;
    for(int i=0;i<2;i++){
        scanf("%d %d",&m,&n);

    a[num] = pq[m]>pq[n]?true:false;
    num++;
    }

}

int main()
{
    struct Graph* G = (struct Graph*)malloc(sizeof(struct Graph));
    CreateGraph(G);
    int pq[G->numVertexes];
    bool a[G->numVertexes];

    if (TopologicalSort(G,pq))
    {
        pan(a,pq);
        for(int i=0;i<2;i++)
        {
            if(a[i]!=0)
                printf("true\n");
            else
                printf("false\n");
        }

    }
    else
    {
        printf("不成立\n");
    }
    return 0;
}