Roger L. Costello

                              David B. Jacobs

什么时候使用rdf:ID？什么时候使用rdf:about?

当你想介绍一个资源，并提供一系列关于这个资源的最初信息的时候使用rdf:ID；当你想扩展关于这个资源的信息时，使用rdf:about。RDF的原理和Web的原理一样：无论什么人，无论什么地方，无论什么时间都能提供关于资源的信息。

解释RDF

<?xml version="1.0"?>

<River xmlns="http://www.geodesy.org/river#">

     <name>Yangtze</name>    

     <length>6300 kilometers</length>

     <startingLocation>western China's Qinghai-Tibet Plateau</startingLocation>

     <endingLocation>East China Sea</endingLocation>

</River>

以上RDF文件理解如下：这是一个River类的实例。其名为Yangtze，长6300千米，起源地位西部青海，结束地点为中国东海。此RDF文档的资源是匿名的，它没有识别符。

rdf:Bag类型：表示一个未排序的集合。如，

<?xml version="1.0"?>

<Meeting rdf:ID="XML-Design-Pattern"

                xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

                xmlns="http://www.business.org#">

     <attendees>

          <rdf:Bag>

               <name>John Smith</name>

               <name>Sally Jones</name>

          </rdf:Bag>

     </attendees>

</Meeting>

rdf:Alt类型：表示一系列供选择的序列。如，

<?xml version="1.0"?>

<Retailer rdf:ID="BarnesAndNoble"      

xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

                xmlns="http://www.retailers.org#">

     <webLocation>

          <rdf:Alt>

               <url>http://www.bn.com</url>

               url>http://www.barnesandnoble.com</url>

          </rdf:Alt>

     </webLocation>

</Retailer>

rdf:Seq类型：用作表示顺序的属性。如，

<?xml version="1.0"?>

<ToDoList rdf:ID="MondayMeetings"

                   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

                   xmlns="http://www.reminders.org#">

     <activities>

          <rdf:Seq>

               <activity1>Meet with CEO at 10am</activity1>

               <activity2>Luncheon at The Eatery</activity2>

               <activity3>Flight at 3pm</activity3>

          </rdf:Seq>

     </activities>

</ToDoList>

ServiceProfile：类似于服务的黄页，描述了服务查询代理用来判断服务是否满足它要求的一组属性信息，如服务提供的功能、输入输出、执行的前提条件、执行的后果等。

ServiceModel：描述了服务的过程模型（使用服务时所涉及的控制流和数据流）。它描述了服务是如何工作的，和ServiceGrounding配合用于服务的自动组合和执行。

ServiceGrounding：将过程模型的描述和WSDL中东通讯协议及消息联系起来。描述了如何访问一个服务。

具体来说，OWL-S基于PDDL（一种用于描述规划领域问题的规范语言），将Web服务看成是AI中的动作或行为，用参数、前提和结果等来描述一个服务，同时输入和输出也作为知识型的前提和结果。在服务组合规划时，需要将这些表示编译成合适的动作形式化描述（例如状态演算。）然而，对于服务组合的支持，OWL-S仍有不足。如，OWL语言基于描述逻辑，在表达一般规则方面有局限性，不能很好地表示用户的偏好和约束。

                                    ----基于语义Web的服务自动组合技术的研究

Resource Description Framework，资源描述框架，是W3C在XML的基础上推荐的一种标准，用于表示任何的资源信息。RDF提出了一个简单的模型用来表示任意类型的数据。这个数据类型由节点和节点之间带有标记的连接弧所组成。节点用来表示Web上的资源，弧用来表示这些资源的属性。因此，这个数据模型可以方便的描述对象（或者资源）以及它们之间关系。RDF的数据模型实质上是一种二元关系的表达，由于任何复杂的关系都可以分解为多个简单的二元关系，因此RDF的数据模型可以作为其他任何复杂关系模型的基础模型。W3C推荐以RDF标准来解决XML的语义局限。

与XML中的标记（tags）类似，RDF中的属性（properties）集也是没有任何限制的。也就是说存在同义词现象和一词多意现象。RDF的模型不具备解决这两个问题的能力，而RDF Schema虽然可以为RDF资源的的属性和类型提供词汇表，但是基于RDF的数据语义描述仍然可能存在语义冲突。为了消解语义冲突，我们在描述数据语义的时候可以通过引用Ontology的相关技术，对语义描述结果作进一步的约束。幸运的是，RDF(Schema)在提供了简单的机器可理解语义模型的同时，为领域化的Ontology语言（OIL，OWL）提供了建模基础，并使得基于RDF的应用可以方便地与这些Ontology语言所生成的Ontology进行合并。RDF的这一特性使得基于RDF的语义描述结果具备了可以和更多的领域知识进行交互的能力，也使基于XML和RDF的Web数据描述具备了良好的生命力。

OWL全称Web Ontology Language，是W3C推荐的语义互联网中本体描述语言的标准。它是从欧美一些研究机构的一种结合性的描述语言DAML+OIL发展起来的，其中DAML来自美国的提案DAML-ONT，OIL来自欧洲的一种本体描述语言。

针对不同的需求OWL有三个子语言，描述列表如下：

“概念化”是指通过确定相关的概念，对生活中某些现象的抽象化建模；“显式”是明确定义使用的概念类型以及对它们的使用约束；“形式化”指定义的ontology应该是机器可读的事实，而不是自然语言；“共享”说明了一个ontology不是个人私有的，而是在一定范围内被人们普遍接受。                             

 ----基于语义Web的服务自动组合技术的研究

描述逻辑(Description Logic)：是一种功能强大的基于逻辑的知识表达语言，可以看成是一种结构化的一阶逻辑，主要用于建模对象和类的丰富层次结构。

Gruber提出的5条规则：

1 明确性和客观性：ontology应该用自然语言对所定义的术语给出明确的、客观的语义定义。

2 完全性：所给定定义是完整的，完全能表达所描述术语的含义。

3 一致性：由术语所得的推论与术语本身的含义是相容的，不会产生矛盾。

4 最大单调可扩展性：向ontology中添加通用或专用的术语时，不需要修改其已有的内容。

5 最小承诺：对待建模对象给出尽可能少的约束。

                                                ----Ontology研究综述

Web服务组合所采用的具体方法和技术依赖于Web服务描述所采用的方法和方式。从服务组合的角度来说，服务描述的主要工作在于选择合适的Web服务描述语言和Web服务模型，有效地为Web服务组合提供必要的信息。

Web服务的输入、输出参数的类型信息之Web服务组合方法中有着重要的地位。但仅仅依赖它似乎不能给出一个正确的Web服务组合。通过对Web服务功能的结构化描述（即Web服务的前提条件及执行结果），我们能够保证获得的组合服务是能够满足查询的要求的。对服务功能进行结构化描述的需求也是导致本体和规则的整合问题成为当前语义Web中的研究热点的一个原因。

总之，语义Web服务组合的自动化离不开自动推理，而各种各样的形式化系统都有其自身在计算复杂度和表达能力之间的权衡和考量。如何选择和设计一个适合语义Web服务组合的形式系统，是语言Web服务组合的自动化中最核心、最基本的问题。

语义Web服务组合的粒度可参照语义Web服务描述分为三个层次。第一层次是在Web服务输入、输出参数的类型上进行服务组合，该层次中的推理对象只涉及到OWL中的类，语义Web刚好能够满足它对推理能力的要求。第二层次上在Web服务执行的前提条件和结构上进行服务组合，该层次通常要借助于OWL之外的推理机制，比如演绎规则系统，但是OWL和演绎规则系统的结合常常导致服务组合算法不可判定。第三个层次是在Web服务外包行为上进行服务组合，它所采用的方法或是借鉴或是直接取自服务验证领域的工作，但通常我们并不会单独地在这个层次上进行服务组合，而是把它当作前面的两个层次上的服务组合方法的有效补充。

                                        ----语义Web服务的自动组合方法：研究综述

Web服务组合方法的研究工作主要来自两个领域：一个是人工智能领域，另一个是形式化方法和自动推理领域。人工智能领域的研究人员从人工智能规划（AI Planning）的角度提出一系列的面向Web服务功能的Web服务组合（规划）方案。来自形式化方法和自动推理领域的工作除了面向Web服务行为的服务组合（验证）方法，也不乏借鉴自动化程序综合和模型检验的方法。

人工智能规划组合方法的不足：

1 无法产生能够与Web服务的非确定性和并发性相适应的组合服务。

2 Web服务的行为特性和经典规划中的动作的行为特征是非常不一样的，这使得规划算法难以在Web服务组合中得到应用。

基于Web服务行为的组合方法：

能克服基于人工智能规划方法的上述不足，但无法满足用户的需求。Web服务的行为通常借助于自动机或进程代数进行表述。改进方法：把消息的参数类型与领域本体中的概念联系起来，并在服务组合时加以考虑，那么就能保证产生的组合服务不仅能在行为上满足用户需求，而且在功能上也能够满足用户需求。

Web服务组合和Web服务匹配的联系是非常密切的，如果把服务组合当作一个状态收索过程的话，那么服务匹配就相当于这个收索过程之中筛选合适的后继状态的步骤。

                                        ----基于Ontology的Web服务组合方法

Void *ptr; // 将 ptr 声明为一个通用指针，但没有指定它指向的东西。

Void 指针最常见的用途是用于声明函数的参数。你可能会希望你的一个函数能够处理不同的类型的参数，可以将 int 变量传递给它，也可以将 float 变量传给它，等等。这样的情况下，你可以将函数声明为接受 void 指针作为参数，则它可以接受任何类型的数据，可以将指向任何东西的指针传递给该函数。如：

Void half(void *val);

下面是一个例子程序：

#include < stdio.h >
void  half( void   * pval, char  type);
int  main( void )
{
int  i = 20 ;
long  l = 100000 ;
float  f = 12.456 ;
double  d = 123.044444 ;

printf( " \n%d " ,i);
printf( " \n%ld " ,l);
printf( " \n%f " ,f);
printf( " \n%lf\n\n " ,d);

half( & i, ' i ' );
half( & l, ' l ' );
half( & d, ' d ' );
half( & f, ' f ' );

printf( " \n%d " ,i);
printf( " \n%ld " ,l);
printf( " \n%f " ,f);
printf( " \n%lf\n\n " ,d);
return   0 ;
}
void  half( void   * pval, char  type)
{
switch (type)
{
  case   ' i ' :
   {
    * (( int   * )pval) /= 2 ;        // 强制转换类型，存取指针pval指向的int变量
    break ;
  }
   case   ' l ' :
   {
    * (( long   * )pval) /= 2 ;        // 强制转换类型，存取指针pval指向的long变量
    break ;
  }
   case   ' f ' :
   {
    * (( float   * )pval) /= 2 ;        // 强制转换类型，存取指针pval指向的float变量
    break ;
  }
   case   ' d ' :
   {
    * (( double    * )pval) /= 2 ;        // 强制转换类型，存取指针pval指向的double变量
    break ;
  }
}
}

程序输出结果：
20
100000
12.456000
123.044444

10
50000
6.228000
61.522222

import java.util.*;

public class CalendarTest
{ 
   public static void main(String[] args)
   { 
      // 首先构造一个日历对象，把它初始化为当前的日期和时间．
      GregorianCalendar d = new GregorianCalendar();

      int today = d.get(Calendar.DAY_OF_MONTH);//得到当前的日期
      int month = d.get(Calendar.MONTH);//得到当前的月份

    
      d.set(Calendar.DAY_OF_MONTH, 1); // 设置d为当前的这个月的第一天
      int weekday = d.get(Calendar.DAY_OF_WEEK); //得到这一天是星期几，如果是星期天的话，weekday被设置为1，依次类推

      System.out.println("Sun Mon Tue Wed Thu Fri Sat");  // 打印标题头和空格作为第一行

    
      for (int i = Calendar.SUNDAY; i < weekday; i++ )//找到第一天对应的星期几的位置
         System.out.print("    ");

      do
      { 
        
         int day = d.get(Calendar.DAY_OF_MONTH);//因为前面设置了d为当前月的第一天，所以第一次循环中day为1
        
         if (day < 10) System.out.print(" ");//如果天小于10，就打印一个空格，然后打印天。
         System.out.print(day);

         if (day == today)//如果这天是当然就在后面打印个*
            System.out.print("* ");
         else
            System.out.print("  ");

        
         if (weekday == Calendar.SATURDAY)// 如果是星期6就在后面进行换行
            System.out.println();

        
         d.add(Calendar.DAY_OF_MONTH, 1);// 然后，我们让d指向下一天
         weekday = d.get(Calendar.DAY_OF_WEEK);//上一句代码设置了为下一天的日期，所以这个weekday为下一天的星期几
      }
      while (d.get(Calendar.MONTH) == month);//如果d在当月中就保持循环
     

    
      if (weekday != Calendar.SUNDAY) // 打印最后的行
         System.out.println();
   }
}

结果输出:
Sun Mon Tue Wed Thu Fri Sat
           　　 　　 1    2    3    4
  5       6        7        8    9    10* 11
 12     13      14      15  16  17  18
19      20      21      22  23  24  25
26      27      28      29  30

#define LEN 20

Struct names{

Char first[LEN];

Char last[LEN];

};

Struct pnames{

Char * first;

Char * last;

};

答案是可以这样声明，但是可能会遇到麻烦，你得理解其含义．考虑以下的代码：

Struct names veep={“Talia”, “Summers”};

Struct pnames treas={“Brad”, “Fallingjaw”};

Printf(“%s and %s\n”,veep.first,treas.first);

　这是一段正确的代码，也能正常运行，但是请思考下字符串存储在哪里？对于 Struct names 变量 veep 来说，字符串存储在结构内部；这个结构共分配了 40 字节来存放两个字符串．然而，对于 Struct pnames 变量 treas 来说，字符串存储在编译器存储字符串常量的任何地方．这个结构存放的只是两个地址而已，在系统中它总共占用 8 个字节． Struct pnames 结构不为字符串分配任何存储空间．它只适用于在另外的地方已经为字符串分配了空间．简单的说， Struct pnames 结构中的指针应该只用来管理那些已经创建的而且在程序其他地方已经分配过空间的字符串．

　再来看看这个限制条件在什么情况下升级为问题：

Struct names accountant;

Struct pnames attorney;

Puts(“Enter the last name of your accountant:”);

Scanf(“%s”,accountant.last);

Puts(“Enter the last name of your attorney”);

Scanf(“%s”,attorney.last);

　语法方面来说，这段代码没有问题，但是考虑下把输入存储到哪里了？对会计师来说，他的名字存储在 accountant 变量的最后一个成员中；这个结构有一个用来存放字符串的数组．对律师来说， scanf() 把字符串放到由 attorney.last 给出的地址中．因为这是个没有初始化的变量，所有该地址可能是任何值，程序就可以把名字放在任何地方．

　所以，我们如果需要一个结构来存储字符串，请使用字符数组成员．存储字符指针有它的用处，但也有被严重误用的可能．

为什么使用指向结构的指针？

1 　就像指向数组的指针比数组本身更容易操作一样，指向结构的指针通常都比结构本身更容易操作.

2 　在一些早期的 C 实现中，结构不能作为参数被传递给函数，但指向结构的指针可以．

3 　许多奇妙的数据表示都使用了包含指向其他结构的指针的结构．
下面是个例子：

/* friends.c -- uses pointer to a structure */
#include <stdio.h>
#define LEN 20

struct names {
    char first[LEN];
    char last[LEN];
};

struct guy {
    struct names handle;
    char favfood[LEN];
    char job[LEN];
    float income;
};

int main(void)
{
    struct guy fellow[2] = {
        {{ "Ewen", "Villard"},
         "grilled salmon",
         "personality coach",
         58112.00
        },
        {{"Rodney", "Swillbelly"},
         "tripe",
         "tabloid editor",
         232400.00
        }
    };
    struct guy * him;    /* 声明指向结构的指针，这个声明不是建立一个新的结构，而是意味
　　　　　　　　　　　　　着指针him现在可以指向任何现有的guy类型的结构*/
  
    printf("address #1: %p #2: %p\n", &fellow[0], &fellow[1]);
    him = &fellow[0];    /* 告诉该指针它要指向的地址  */
    printf("pointer #1: %p #2: %p\n", him, him + 1);
    printf("him->income is $%.2f: (*him).income is $%.2f\n",
         him->income, (*him).income);
    him++;               /*指向下一个结构*/
    printf("him->favfood is %s:  him->handle.last is %s\n",
         him->favfood, him->handle.last);
   
    return 0;
}

输出结果：
address #1: 0240FEB0 #2: 0240FF04
pointer #1: 0240FEB0 #2: 0240FF04
him->income is $58112.00: (*him).income is $58112.00
him->favfood is tripe:  him->handle.last is Swillbelly
Press any key to continue...

　从输出看出 him 指向 fellow[0],him+1 指向 fellow[1] ．注意 him 加上 1 ，地址就加了 84 ．这是因为每个 guy 结构占用了 84 字节的内存区域．
　使用指针访问成员的方法：

1 　 him->income 但是不能 him.income ，因为 him 不是一个结构名．

2 　如果 him=&fellow[0], 那么 *him=fellow[0] ．因为 & 与 * 是一对互逆的运算符．因此，可以做以下替换：
fellow[0].income= =(*him).income 注意这里必须要有圆括号，因为 . 运算符比 * 的优先级高．