线性表C++实现(重写了一遍)

Posted 2023-04-06 楚江_wog1st

我把链表，数组写一起了，用.h文件和.cpp文件写了一遍，没有抄之前的代码，思路可能会有不一样的地方，重要的点都有注释，没有的地方不会的就问我

.h文件

//
// Created by Administrator on 2023/3/31.
//

#ifndef SHUJUJIEGOU_LIST_H
#define SHUJUJIEGOU_LIST_H

#endif //SHUJUJIEGOU_LIST_H

using namespace std;


/**
 * 假设线性表第0位为空，现在用来放线性表长度
 * 线性表基本操作：
 * InitList(&L) 初始化表
 * Length(L) 求表长
 * LocateElem(L,e) 按值查找
 * GetElem(L,i) 按位查找
 * ListInsert(&L,i,e) 插入操作，在表的第i个位置插入元素e
 * ListDelete(&L,i,&e) 删除操作，删除表上第i个位置的元素，返回给e
 * PrintList(L) 输出操作
 * Empty(L) 判空操作
 * DestroyList(&L) 销毁操作
 */
void InitList(int L []);
void Length(int L []);
int LocateElem(const int L [] , int e);
int GetElem(int L[], int i);
void ListInsert(int L [] , int i , int e);
void ListDelete(int L [] , int i , int &e);
void PrintList(int L []);
int Empty(const int L []);
void DestroyList(int L []);
/*
 * 已知一个整数序列A=(a_0,a_1,a_2,...,a_n-1)，其中0≤a_i≤n(0≤i<n)。如果存在a_p1=a_p2=...=a_pm=x且m>n/2(0≤p_k<n,1≤k≤m)，
 * 则称x为A的主元素。例如A=(0,5,5,3,5,7,5,5)，则5为主元素；又如A=(0,5,5,3,5,1,5,7)，则A中没有主元素。假设A中的元素保存在一个一维数组中，
 * 请设计一个尽可能高效的算法，找出A的主元素。若存在主元素，则给出该元素；否则输出-1
 *
 */
int GetMajority(const int L[]);
/*
 * 定义三元组(a,b,c)(a,b,c均为正数)的距离D=|a-b|+|b-c|+|c-a|。给定3个非空整数集合S_1,S_2,S_3，按升序分别存储在3个数组中。请设计一个尽可
 * 能高效的算法，计算并输出所有可能的三元组(a,b,c)(a∈S_1,b∈S_2,c∈S_3)中的最小距离。例如S_1=-1,0,9, S_2=-25,-10,10,11,
 * S_3=2,9,17,30,41则最小距离为2，相应的三元组为(9,10,9)。
 */
int GetMinDistance(int S1[], int S2[], int S3[]);


//单链表,同时让头指针存链表长度
typedef struct LNode
    int data;
    struct LNode* next;
LNode,*LinkList;
//初始化链表
LinkList Init_LinkList();
//头插法建立单链表(函数内部就不去再调用cin或者是scanf了，太蠢了，增加一个列表形参,列表处理和上面的列表相同，数据下标从1开始，0位置存长度)
LinkList List_HeadInsert(LinkList &L , const int A []);
//尾插法建立单链表
LinkList List_TailInsert(LinkList &L , const int A []);
//按序号查找节点值
LNode* GetElem(LinkList L, int i);
//按值查找表节点
LNode* LocateElem(LinkList L, int e);
//插值操作：在第p个节点后插入
void LNode_InsertTail(int e, LNode* p);
//插入操作：在第p个节点前插入
void LNode_InsertHead(LinkList L, int e, LNode* p);
//删除节点操作
void Delete_LNode(LinkList L, LNode *p);
//求表长
int GetLength(LinkList L);

//有一个带头节点的单链表L，编写算法使其元素递增有序
//方法一：用类似快排的方式去写这个代码，有一个起始指针和一个终止指针，我们的id值是每个子链表的第一个节点，比当前节点小的节点我们删掉然后用头插法
//插进去，比当前节点大的节点我们直接忽略掉，进行下一个节点的判断，id节点最后会移动到一个位置，于是分出了两个子链表。但是毕竟是链表，不是很方便。
//方法二：插入排序
void Sort_LinkList(LinkList L);

//给定两个单链表，编写算法写出两个单链表的公共节点的起始位置
LNode* Both_Have(LinkList L1, LinkList L2);

//再不改变链表的前提下，设计一个尽可能高效的算法，查找链表中倒数第k个位置上的节点(k为正整数)，若查找成功，算法输出该节点的data值，并返回1，否则只
//返回0
int Get_k_Tail(LinkList L, int k);

//现要求设计一个时间复杂度尽可能高效的算法，对于链表中data的绝对值相等的节点，仅保留第一次出现的节点而删除其余绝对值相等的节点。
void Delete_Same_abs(LinkList L);

//设有线性表L=(a_1,a_2,a_3,...a_n-2,a_n-1,a_n)采用带头节点的链表存储
// 设计一个空间复杂度为O(1)且时间上尽可能高的算法，重新排列L中的各节点，得到线性表L'=(a_1,a_n,a_2,a_n-1,...)
LinkList Resort(LinkList L);


//双链表
typedef struct DNode
    int data ;
    struct DNode * next;
    struct DNode * pre;
DNode, *DLinkList;
//双链表的插入操作(默认为第p位置的后面)
void DNode_InsertTail(DLinkList DL, int e , DNode* p);
//双链表的删除操作
void DNode_Delete(DNode *p);

//循环链表


//静态链表
//以next==-1作为结束的标志
typedef struct 
    int data;
    int next;
StaticLinkList[INT_MAX];

.cpp文件

//
// Created by Administrator on 2023/3/31.
//
#include <iostream>
#include "../Public/List.h"


using namespace std;


/**
 * 假设线性表第0位为空，现在用来放线性表长度
 * 线性表基本操作：
 * InitList(&L) 初始化表
 * Length(L) 求表长
 * LocateElem(L,e) 按值查找
 * GetElem(L,i) 按位查找
 * ListInsert(&L,i,e) 插入操作，在表的第i个位置插入元素e
 * ListDelete(&L,i,&e) 删除操作，删除表上第i个位置的元素，返回给e
 * PrintList(L) 输出操作
 * Empty(L) 判空操作
 * DestroyList(&L) 销毁操作
 */


void InitList(int L [])
    int *List = new int [20];
    L = List;
    for(int i = 0 ; i < 20 ; i++)
        L[i] = -1; //初始化
    


void Length(int L [])
    int i = 0;
    int count = 0;
    while(L[i]!=-1)
        count++;
        i++;
    
    L[0] = count;



//此处用二分法优化,前提是线性表为一个有序列表
//返回-1表示没有找到
int LocateElem(const int L [] , int e)
    int low = 1;
    int high = L[0]-1;
    int mid ;
    while(low<high)
        mid = (low+high)>>1;
        if (L[mid]>e)
            high = mid-1;
            continue;
         else if (L[mid]<e)
            low = mid+1;
            continue;
         else 
            return mid;
        
    
    return -1;



int GetElem(int L[], int i)
    if (i>=L[0]) return -1;
    else return L[i];


void ListInsert(int L [] , int i , int e)
//    判断是否越界
    if (i>=L[0])
        printf("OUT OF BOUNDARY!");
        return;
    
    else
//        在表长内，先挪位置
        for (int j = L[0]; j >= i; --j) 
            L[j+1] = L[j];
        
        L[i] = e;
        cout<<L[i]<<endl;
        L[0]++;
    



void ListDelete(int L [] , int i , int &e)
//    判断是否越界
    if (i>L[0])
        cout<<"OUT OF BOUNDARY"<<endl;
        return;
    
    e = L[i];
//    用覆盖的方式去删除
    for (int j = i; j <= L[0] ; ++j) 
        L[j] = L[j+1];
    
    L[0]--;


void PrintList(int L [])
    for (int i = 1; i <= L[0]; ++i) 
        cout<<L[i]<<endl;
    


int Empty(const int L [])
    if (L[0]==0)return 1;
    else return 0;


void DestroyList(int L [])
    free(L);



/*
 * 已知一个整数序列A=(a_0,a_1,a_2,...,a_n-1)，其中0≤a_i≤n(0≤i<n)。如果存在a_p1=a_p2=...=a_pm=x且m>n/2(0≤p_k<n,1≤k≤m)，
 * 则称x为A的主元素。例如A=(0,5,5,3,5,7,5,5)，则5为主元素；又如A=(0,5,5,3,5,1,5,7)，则A中没有主元素。假设A中的元素保存在一个一维数组中，
 * 请设计一个尽可能高效的算法，找出A的主元素。若存在主元素，则给出该元素；否则输出-1
 *
 */
int GetMajority(const int L[])
    //初始化
    int id = L[1];
    int count = 1;

//  找出个数最多的那个元素，前面的指定元素个数和后面的其它元素个数相互抵消，只要前面的指定元素够多，那么id所指的元素一定是前面的那个指定元素
//  如果前面的指定元素个数不够多，那么当指定元素的个数被抵消完后，会将下一个元素重设为指定元素，然后继续进行抵消，整个数组遍历下来会有几个情况：
//  1.count结果=0，意味着所有指定元素的个数(赋值给id的元素)等于未指定的所有元素的个数之和(没有给id赋值的)，那么指定过的元素也肯定不是主元素
//  2.count结果>0，意味着这个count所指向的元素就是这个数组内出现次数最多的，但是还需要确定该元素出现的次数是否大于数组长度的一半

//  寻找出现次数最多的元素
    for (int i = 2; i <= L[0]; ++i) 
        if (id == L[i])
            count++;
         else
            if (count>0)
                count--;
             else
                count = 1;
                id = L[i];
            
        
    

//  确定指定元素的出现次数是否大于数组长度的一半
    if (count>0)
        count = 0;
        for (int i = 1; i <= L[0]; ++i) 
            if (id==L[i])
                count++;
            
        
        if (count>L[0]/2) return id;
        else return -1;
    

    return -1;


/*
 * 定义三元组(a,b,c)(a,b,c均为正数)的距离D=|a-b|+|b-c|+|c-a|。给定3个非空整数集合S_1,S_2,S_3，按升序分别存储在3个数组中。请设计一个尽可
 * 能高效的算法，计算并输出所有可能的三元组(a,b,c)(a∈S_1,b∈S_2,c∈S_3)中的最小距离。例如S_1=-1,0,9, S_2=-25,-10,10,11,
 * S_3=2,9,17,30,41则最小距离为2，相应的三元组为(9,10,9)。
 */

bool xls_min (int a , int b , int c)
    if (a<=b&&a<=c) return true;
    return false ;


int GetMinDistance(int S1[], int S2[], int S3[])
//  做个假设，对于三个数组和三元组内的三个值来说，顺序都无所谓，所以可以假设a<b<c这样方便做题
//  距离D可以转化为2(|a-b|+|b-c|)或者是2|a-c|但是第二个等式成立有个前提那就是存在b∈一个数组，使得a<b<c也就是说这个b一定是中间值
//  定义一个D值为最大值，确保D一定会被重新赋值
//  题给三个数组都是递增数组，那么我们直接从数组的第一个元素开始计算D值，每次取最小的那个值进行放大，然后重新算D求最小值，相当于一次所有表的遍历
    int i=1,j=1,k=1;//三个数组的指针
    int D_min = INT_MAX;
//  指针走到头之前
    while(i<=S1[0]&&j<=S2[0]&&k<=S3[0]&&D_min>0)
        int D = abs(S1[i]-S2[j])+ abs(S1[i]-S3[k])+ abs(S2[j]-S3[k]);
        if (D<D_min)
            D_min = D;
        
        if (xls_min(S1[i], S2[j], S3[k]))i++;
        else if (xls_min(S2[j], S1[i], S3[k])) j++;
        else k++;
    
    return D_min;


LinkList Init_LinkList()
    auto *L = new LNode;
    L->next = nullptr;
    L->data = 0;
    return L;


LinkList List_HeadInsert(LinkList &L , const int A [])
    for (int i = 1; i <= A[0]; ++i) 
        auto * p = new LNode ;
        p->data = A[i];
        p->next = L->next;
        L->next = p;
        L->data++;
    
    return L;


LinkList List_TailInsert(LinkList &L , const int A [])
    //定义一个指向链表尾部的指针
    LNode* Tail = L;
    for (int i = 1; i <= A[0] ; ++i) 
        auto *p = new LNode;
        p->data = A[i];
        Tail->next = p;
        p->next = nullptr;
        Tail = p;
        L->data++;
    
    return L;


LNode* GetElem(LinkList L, int i)
    if (i>L->data)return nullptr;
    //计数，直到找到第i个节点为止
    int index = 0;
    LNode *p = L;
    while (index!=i)
        p = p->next;
        index++;
    
    return p;


LNode* LocateElem(LinkList L, int e)
    int index = 0;
    LNode *p = L;
    while(index<=L->data||p->next)//二选一
        p = p->next;
        index++;
        if (p->data == e)return p;
    
    return nullptr;



void LNode_InsertTail(int e, LNode* p)
    auto * a = new LNode ;
    a->data = e;
    a->next = p->next;
    p->next = a;


void LNode_InsertHead(LinkList L, int e, LNode* p)
    auto* index = new LNode ;
    index->next = L->next;
    while (index->next&&index->next!=p)
        index = index->next;
    
    if (index->next)
        auto *a = new LNode ;
        a->data = e;
        a->next = index->next;
        index->next = a;
    


void Delete_LNode(LinkList L, LNode *p)
    auto *index = new LNode ;
    index->next = L->next;
    while (index->next&&index->next!=p)
        index = index->next;
    
    index->next = p->next;
    free(p);


int GetLength(LinkList L)
    return L->data;


void DNode_InsertTail(int e , DNode* p)
    auto *a = new DNode;
    a->data = e;
    a->next = p->next;
    a->pre = p;
    p->next->pre = a;
    p->next = a;


void DNode_Delete(DNode *p)
    p->pre->next = p->next;
    p->next->pre = p->pre;
    free(p);


//插入排序
//一共需要3个指针，两个拿来指向原来的链表，一个用来指向新的链表
void Sort_LinkList(LinkList L)
    LinkList res = Init_LinkList();
    auto *p = L->next;
    auto *temp = p->next;
    auto *new_p = res;
    while (p)
        new_p = res;
        while (new_p->next&&new_p->next->data<p->data)
            new_p = new_p->next;
        
        LNode_InsertTail(p->data, new_p);
        free(p);
        p = temp;
        temp = p->next;
    
    L->next = res->next;
    free(res);


LNode* Both_Have(LinkList L1, LinkList L2)
    int len;
    bool flag;
    if (L1->data>L2->data)
        len = L1->data-L2->data;
        flag = true;
     else 
        len = L2->data-L1->data;
        flag = false;
    
    auto *p1 = L1 ;
    auto *p2 = L2 ;
    int i = 0 ;
    if (flag)
        while (i<len) 
            p1 = p1->next;
            i++;
        
     else
        while (i<len)
            p2 = p2->next;
            i++;
        
    
    while(p1->next&&p2->next&&p1->next!=p2->next)
        p1 = p1->next;
        p2 = p2->next;
    
    if (p1->next)return p1->next;
    else return nullptr;


//时间复杂度为2n，也就是O(n)
int Get_k_Tail(LinkList L, int k)
    //先遍历一遍查长度
    int len = 0;
    auto *p = L;
    while (p->next)
        len++;
        p = p->next;
    
    //如果len<k，那么直接输出0
    if (len<k)return 0;
    auto *r = L;
    p = L;
    int i = 0;
    while (i<len)
        p = p->next;
        i++;
    
    while (p->next)
        p = p->next;
        r = r->next;
    
    cout<<r->data<<endl;
    return 1;


void Delete_Same_abs(LinkList L)
    auto *p = L->next ;
    auto *r = L;
    bool *flag =new bool [INT_MAX];
    while (p)
        if (flag[p->data]) 
            flag[p->data] = true;
            r = p;
            p = p->next;
        
        else 
            r->next = p->next;
            free(p);
            p = r->next;
        
    


LinkList Resort(LinkList L)
    auto* p = L->next;
    auto* q = L;
    auto* new_L = Init_LinkList() ;
    auto*r = new LNode ;
    int len = 0;
    //先看长为多少
    while (p)
        len++;
        p = p->next;
    
    //让新的头节点指向中间的那个节点,同时断开，变成两个子链表
    for (int i = 0; i < len/2+len%2; ++i) 
        q = q->next;
    
    r = q->next;
    //用头插法进行倒序
    while(q)
        new_L->next = q;
        q->next = new_L->next;
        q = r;
        r = q->next;
    
    //进行插入操作
    p = L->next;
    q = new_L->next;
    r = q->next;
    //当两个链表不为空的时候,进行插值操作
    while (p&&q)
        q->next = p->next;
        p->next = q;
        p = q->next;
        q = r;
        r = q->next;
    

    return L;

重写了一遍授权思路

AuthorizationCore

授权项目

通过将授权项、角色、相应对象相关联的方式来判断，请求对象是否有权限进行相应的操作。

项目分析

简单点说授权就是一个对象（可能是个人；可能是个角色），在进行某件事情之前，根据一定的数据设定计算，被请求对象（动作的依附对象，可能是一个文件也；可能是某一个类文件；）的某一个动作（可能是文件的读写；可能是某一个方法）是否有权利完成。

名词简介

请求对象

自然人

张三、李四某一个系统中的具体的用账号密码登录的人员都可以被认为是自然人。

角色

某些情况下我们可能非常难做到自然与实际的被请求对象之间的关心，因为这实在是一件太庞大的数据了。比如张三对于张三的博客是博主，所以张三对于张三的博客拥有管理权限。但是李四并不是张三博客的博主，所以李四并不能管理张三的博客。我们可以直接对张三跟战三的某一篇博客建立请求与相应之间的关系，但是这个数据量会变得非常庞大。所以某些情况下，我们只能先通过数据计算张三与战三博客的关系，然后在通过这个关系来判定数据的权限。

其他

当然这个地方可以存在其他，请求对象只是一个请求对象而已。比如说，我们现在要建立一个平台服务，这个服务可以提供很多API给其他的系统，但是每一个系统所能调用的API接口不尽相同。那么，我们怎样通过我们的授权服务来判定哪几个接口可以调用，哪几个不可以呢？比如我们可以将某一个系统作为一个请求对象来调用服务，就可以做到相应的权限管控了。当然还有很多很多其他的情况，我在这里只是简单的举个例子，为大家抛砖引玉

响应对象

既然存在请求，那么相对的就会存在响应对象。那么响应对象一般情况下可以是什么呢？

具体的响应对象

具体的响应对象可以是某一个文件，比如你想删除掉这个文件，我们就可以具体判断你对这个文件是否拥有某些权限，这个时候文件就是一个响应对象。也可以是一个组织，比如你想操作这个组织，修改这个组织的头像。这个时候这个组织就是一个具体的响应对象。

逻辑意义对象

就像是我们在 请求对象-角色 中提到的那样，很多时候我们并不能规定某些具体的人对于某些具体的对象的权限，因为这些对象实在是太多了，如果动态的维护这些数据，那是一件非常痛苦的事情。所以我们提出了上边的对象概念，那么久会扯出来另一个概念，逻辑意义对象，张三的博客对于张三来说，实际上就是自己的博客。当然李四的博客对于李四来说也是自己的博客，从这个地方上来讲，这两个自然人对于这两个实际的对象拥有相同的授权。自己的博客并不是特指某一个具体的对象而是指某个逻辑上的对象。

某些业务场景

像是前文中提到的某一个类中的函数允不允许调用的问题。这个时候就是某些业务场景。当然这个可以认为是某一个具体的响应对象，毕竟那个类就是那个类。不过这个地方因为不牵扯到具体的类的实例，所以还是单独拿出来归为一类比较好

其他

……

角色

这个角色有别于之前提到的角色，但是两者非常类似。角色定义为某个人拥有的身份，比如说，张三是张三儿子的老师，那么张三对于张三儿子就有多个身份：父亲、老师、可能还有朋友。假设我们来规定不同的身份对于战三的儿子拥有不同的权利。那么张三对于张三儿子的权利还蛮多的毕竟身份也有很多。

角色

角色对于角色这个地方可能非常容易理解，因为角色就是角色嘛。不过角色还会支持一个高级特性。权限合并这个一会我们在讲。

个人

某些情况，我们需要给某一个人进行授权，这个时候我们可能需要创建一个对象，专门用来表示这个个人。因为个人表示某一个个人，所以个人与个人之间并没有什么直接关系。比如说张三和李四，他们之间除了都是人可能也没有啥太特殊的关系。

组织

一般情况下，个人也好。请求对象中的角色也好，一般都是归属于某些组织的。当然组织是在其他系统中实现的，组织的内容我们不做过多的展开，组织的概念呢就是根据这些组织结构相对应的角色对象。比如说，张三归属于红星公司的研发部。这个地方可能就会产生两个角色，红星公司跟研发部。而张三则因为组织结构的原因会被设置到研发部这个角色下拥有研发部角色的相关权利。

权限继承

角色篇章里边，我们提到了战三与研发部的关系。不过张三只属于研发部嘛？应该不是，研发部属于红星公司，那么张三自然也就属于红星公司。那么我们现在有两条路可以选，张三可以同时拥有两个角色，我们将两个角色的权利合并，我们就可以得到张三的的所有权利。另一条路，张三属于研发部，研发部属于红星公司，将红星公司的权利赋予研发部，那么张三自然拥有了所有的权限。其实想来看看，如果组织结构层级非常深的情况下，那么张三会拥有非常非常多的角色。这也是一件非常恐怖的事情，所以我们要走第二条路。其实不光是组织，所有的角色对象都应该是这样的，不过，讲道理个人不应该被继承。

权限合并

讲完了继承，我们该讲讲合并了。张三跟他儿子的关系的时候，我们就提到了很常见的情况就是一个请求对象对应一个相应对象有非常多的角色。当你想验证你做一件事情是否拥有权限的时候，就应该将你所有的权限合并起来，然后综合来看你对想做的事情究竟拥有怎样的授权。

权限的状态

在讲合并之前得先讲讲权限的几种状态：未定义、通过、拒绝。

未定义

这事我不管你们看着办，行也可以，不行也可以。

通过

好了我觉得这事能行。

拒绝

不行这事不行

合并

• 只要所有的授权项中有一项是拒绝的，那么整个授权结果都是拒绝的。
• 如果所有的授权项中都是通过或者未定义则将授权项定义为通过。
• 如果所有的授权项都是未定义的，则合并结果为未定义。

后边两条或许还好理解一些，第一条则需要着重解释一下。其实这个地方来源于两个概念，黑名单和白名单。他们分开使用的情况下应该非常容易理解，但是他们一旦一块使用了，并且同一个人出现在了两个名单里边，就让人难以抉择了。那么我们应该怎么办呢，让我们先看一下后边的例子。

让我的老师远离我的QQ空间：
你申请了一个QQ，你有一个QQ空间。但是你不想让你的老师看到你的QQ空间。其他人是无所谓的，那么一般情况下会这么设置：1.任何人都可以看；2.我的老师不能看；这个时候你的老师就会出现在两个冲突的授权中（你的老师是所有人的一员，你的老师也是你的老师）。在这种情况下我们取什么值呢？答案很显然是不通过，否则就违背了我们的本意。

多群组：
张三同时加入了两个组织，而这两个组织是相互有利益冲突的。假设他们现在建立了一条规矩，说属于对方组织的人是不能够访问我们的资源的；我们自己组织里边的人时可以访问我们的资源的。那么拥有两个组织的资源访问权限吗（毕竟他既属于自己的组织又属于对面的组织）？其实考虑这个问题应该从设置规矩的出发点上来看待这个问题，其实就是害怕对方的组织访问了自己的东西，而给自己的组织造成了利益上的伤害。那么从这个角度出发张三是没有权限的。
或许你会考虑张三既然属于了组织那么就应该享有权利，如果不想让张三拥有权利，可以通过某些授权来解决问题

其他的手段保证合并

• 不让战三加入组织。确实可以解决，并且大部分情况下组织如果有冲突的话，一般情况下也确实不会让他们相互加入，但是在某些情况下是没有机制保证这件事情的。所以这种做法可能没有照顾的那么全。
• 踢出授权范围。比较常见，比如说除了张三的所有人都享有权利。但是这个在数据表达上可能就比较困难。虽然可以做，但是相关的表达这句话的程序数据模型就会变得非常复杂，所以也比较困难

授权项

其实讲到这里，缺少什么也应该比较清楚了。就是缺少了具体的动作。比如说访问资源、访问QQ空间。这些都是依附在响应对象上的具体动作。

授权项的依附

授权项是依附在响应对象身上的。回到最开始的文件案例上来。某一个具体的文件上的读、写、删这些授权项都是依附在某一个具体的文件对象身上的。

权限项的分类

其实相同的内容会有相同的权限项。比如文件类型的响应对象，那么无非也就是读、写、删这么几个动作。别的你应该也没有办法弄对吧；那么对于QQ空间来说就是被访问；响应对象应该会存在一个类型，然后授权项的模板应该是依附在相应对象类型身上的。

END