软件体系结构KWIC实验
KWIC
KWIC一．实验原理基本面向对象方案：该方案是个基本的面向对象方案，有四个基本功能类：input, shift, alphabetize 和output，将这些功能在主程序中串联起来，通过共享数据的方式组成整个系统。
流程很简单，首先通过input类获取需要处理的英文语句行，接着使用shift进行移位操作，得到一行行的结果，此时再采用alphabetizer 对这些行进行首字母排序，最后采用output类输出。
设计了一个Kwic类对上述类进行整合。
评价：将各个功能模块分开设计，并且利用权限控制保证了封装的特性，系统的扩展性和封装性增强。
二．实验代码#include<iostream>#include<string>#include<algorithm>using namespace std;#define maxs 100int N=0,A=0,Q=0;int M=0,G=0,P=0;struct sentence{string str[maxs];string str1[maxs];int L;int Q;};struct SS{string STR;};int Menu(){int i;cout<<" KWIC算法"<<endl;cout<<"1.输入（“#”结束输入） 2.移位 3.排序 4.退出"<<endl;cout<<"你的选择（n>=1&&n<=4）请输入"<<endl;cin>>i;if(i<=0||i>4){cout<<"输入错误,请重新输入i值:"<<endl;cin>>i;}return i;}void input(sentence *p){int i=0;cin>>p[M].str[i];while(p[M].str[i++]!="#"){cin>>p[M].str[i];}p[M].L=i-2;cout<<p[M].L<<endl;M++;}void shift(sentence *p,SS *q){int i=0,j,k=0,Z=1,l,a=0;string s;A=0;while(a<M){i=0;for(j=0;j<=p[a].L;j++)p[A].str1[j]=p[a].str[j];p[A].Q=p[a].L;cout<<endl;A++;while(i<p[a].L)k=p[a].L;s=p[A-1].str1[p[a].L];while(k>0){--k;p[A].str1[k+1]=p[A-1].str1[k];}p[A].str1[0]=s;p[A].Q=p[a].L;i++;A++;}a++;}for(l=0;l<=A;l++)for(j=0;j<=p[l].Q;j++){cout<<p[l].str1[j]<<" ";if(j==p[l].Q)cout<<endl;}cout<<endl;}void gether(sentence *p,SS *q){int i,j;for(j=0;j<A;j++)for(i=0;i<=p[j].Q;i++){q[j].STR=q[j].STR+" ";q[j].STR=q[j].STR+p[j].str1[i];}}void main(){int i,j,n,x=0;string ss[100];sentence *p1=new sentence[maxs];SS *q=new SS[maxs];switch(Menu()){case 1:input(p1);break;case 2:shift(p1,q);break;case 3:gether(p1,q);for(i=0;i<A;i++){ss[i]=q[i].STR;x++;}sort(ss,ss+x);for(i=0;i<x;i++)cout<<ss[i]<<endl;break;case 4:cout<<"退出!"<<endl;exit(0);}}。
软件体系结构实验报告
一、实验目的1. 理解软件体系结构的基本概念和原理。
2. 掌握两种常见的软件体系结构风格：顺序批处理和管道-过滤器。
3. 通过实际操作，加深对软件体系结构设计方法和实践的理解。
二、实验内容1. 实验题目：软件体系结构实验2. 实验目的：（1）理解软件体系结构的基本概念和原理。
（2）掌握顺序批处理和管道-过滤器两种软件体系结构风格。
（3）通过实际操作，加深对软件体系结构设计方法和实践的理解。
3. 实验要求：（1）熟悉Java编程语言。
（2）了解面向对象编程思想。
（3）掌握软件体系结构设计的基本原则和方法。
4. 实验器材：（1）计算机一台。
（2）Java开发环境。
（3）实验指导书。
三、实验步骤1. 创建实验项目，并设置项目属性。
2. 设计顺序批处理风格的软件体系结构。
（1）创建一个数据流问题，例如计算10000个数的平均值。
（2）将数据流问题分解为多个处理步骤，如读取数据、计算平均值、输出结果等。
（3）为每个处理步骤创建相应的类，实现具体功能。
（4）编写主程序，将数据流问题传递给各个处理步骤，实现整个数据流处理过程。
3. 设计管道-过滤器风格的软件体系结构。
（1）创建一个数据流问题，例如过滤并输出指定范围内的偶数。
（2）将数据流问题分解为多个处理步骤，如读取数据、过滤数据、输出结果等。
（3）为每个处理步骤创建相应的类，实现具体功能。
（4）通过接口连接各个处理步骤，实现数据流的传递和处理。
4. 编写实验报告，总结实验过程和心得体会。
四、实验结果分析1. 批处理风格与管道-过滤器风格的比较：（1）批处理风格：数据以整体的形式传输，数据总量有限；处理过程之间互不调用。
（2）管道-过滤器风格：数据以数据流的形式传输，数据量可以无限制；处理过程之间通过接口连接，实现数据流的传递和处理。
2. 实验过程中遇到的问题及解决方法：（1）问题：如何设计合理的处理步骤？解决方法：根据数据流问题，将问题分解为多个处理步骤，并确保每个步骤的功能单一、易于实现。
软件体系结构实验报告
软件体系结构实验报告实验指导书实验一1、实验项目：软件体系结构设计（一）某系统C/S风格客户端软件体系结构设计2、实验目的：熟悉C/S风格的工作机制3、实验内容：针对某个应用系统，选用C/S风格作为这个系统的软件体系结构风格。
熟悉C/S风格的工作机制，对所考察的系统进行C/S风格客户端软件体系结构设计。
（针对不同的特定应用系统具体表述）实验二1、实验项目：软件体系结构设计（二）某系统C/S风格服务器软件体系结构设计2、实验目的：熟悉C/S风格的工作机制3、实验内容：针对某个应用系统，选用C/S风格作为这个系统的软件体系结构风格。
熟悉C/S风格的工作机制，对所考察的系统进行C/S风格服务器软件体系结构设计。
（针对不同的特定应用系统具体表述）实验三1、实验项目：UML建模某系统UML建模2、实验目的：深入理解UML建模的思想，熟悉UML建模方法3、实验内容：作为实际应用前的一种演练，深入理解UML建模的思想，熟悉UML建模方法，锻炼和培养分析问题、解决问题的能力。
针对某个选定的应用系统，对其进行用例建模、对象类建模和状态图建模。
实验四1、实验项目：某系统详细设计2、实验目的：细化前期设计的有关结果，做出软件的详细规格说明3、实验内容：详细设计（也叫过程设计）是软件设计的具体模块设计阶段，是在作为软件开发前期设计的体系结构设计和总体设计的基础上进行的。
目的是要细化前期设计的有关结果，做出软件的详细规格说明。
要求具体地设计目标系统给个模块的实现过程。
实验五1、实验项目：系统集成2、实验目的：系统集成与总结3、实验内容：综合考察前八次实验的内容，通盘考虑软件设计的整个过程，深入理解软件体系结构的构建过程教务管理系统序号名称基本属性1 教师教师号,姓名,性别,职称,出生日期,政治面貌,所属系部,身份证号,档案编号2 系部系部号,系部名称,办公地点,电话3 专业专业代号,专业名称,所属系部4 教室教室号,类型(语音室,实验室,多媒体教室,普通教室等),规格,管理员,备注5 课程课程号,课程名称,开课系部,课程简介6 学生学号,姓名,性别,班级,出生日期,籍贯,民族,政治面貌,身份证号,高考成绩,档案编号7 班级班级号,班级名称,专业,人数8 成绩学号,课程号,成绩,备注(缓考,补考,重修等)9 考试安排课程号,教程号,学生,时间10 评教/评学班级,教师,课程,评教分数,评学分数11 选课学号,课程号,教师号12 排课课程号,教师号,教室号,时间13 开课计划序号,专业代号,课程号,学期,学时,学分,课程性质(选修,必修),教学方式(普通教学,多媒体教学,户外教学等)要求:1.建立教务系统的需求分析模型,并声称需求分析报告;2.建立教务系统的业务流程模型;3.建立教务系统的概念数据模型;4.建立教务系统的物理数据模型(创建数据库,生成数据库);5.通过教务系统的物理数据模型生成面向对象模型(OOM),生成对应的JA V A或者C#代码;实验一里面可以用Adobe Dreamweaver或者VisualStudio2008或者以上版本描述相关的前台界面;实验二: 用以上的工具构建相关的后台界面;实验三: 用PowerDesigner设计该系统的需求分析和业务业务流程模型(BPM)实验四: 用PowerDesigner设计该系统的CDM和PDM实验五: 用PowerDesigner 设计该系统的OOM和对应的JA V A 或C#代码.附录1：实验报告模板实验一软件体系结构设计（一）某系统C/S风格客户端软件体系结构设计实验课程名：软件体系结构专业班级：学号：姓名：实验时间：实验地点：指导教师：说明：1.验证性实验报告填写好后，以学生的学号+实验项目名作为该word文件名保存，例如某学生学号为20080001，姓名为某某，本次实验名称是：实验1 线性表的实验，则本次实验报告的保存文件名为：01某某实验1.doc。
软件体系结构KWIC实验
软件体系结构KWIC实验《软件体系结构》实验：软件体系结构风格之应⽤⼀、实验⽬的通过KWIC 实例分析，理解和掌握软件体系结构风格设计与实现。
⼆、实验内容多种软件风格设计与实现之KWIC 实例：1．采⽤主/⼦程序体系结构风格实现KWIC 关键词索引系统2．采⽤⾯向对象体系架构风格实现KWIC 关键词索引系统 3．采⽤管道过滤体系架构风格实现KWIC 关键词索引系统4．采⽤事件过程调⽤体系架构风格实现KWIC 关键词索引系统三、实验要求与实验环境熟练掌握基于主/⼦程序体系结构风格的KWIC 关键词索引系统，在此基础上，完成基于⾯向对象体系架构风格的KWIC 关键词索引系统设计与实现。
选做基于管道过滤体系架构风格的KWIC 关键词索引系统；选做基于事件过程调⽤体系架构风格的KWIC 关键词索引系统。
实验课前完成实验报告的实验⽬的、实验环境、实验内容、实验操作过程等内容；实验课中独⽴/团队操作完成实验报告的实验操作、实验结果及结论等内容；每⼈⼀台PC 机，所需软件Win2003/XP 、UML ⼯具（EclipseUML/Rose/Visio/StartUML/）、Eclipse/MyEclipse、JDK6.0 等。
四、实验操作1、采⽤主/⼦程序体系结构风格实现KWIC 关键词索引系统主程序/⼦程序风格（Main Program/Subroutine Style）将系统组织成层次结构，包括⼀个主程序和⼀系列⼦程序。
主程序是系统的控制器，负责调度各⼦程序的执⾏。
各⼦程序⼜是⼀个局部的控制器，调度其⼦程序的执⾏。
设计词汇表：主程序main(), ⼦程序shift(), sort() ⽅法，⽅法的调⽤，返回构件和连接件类型：构件：各类⼦程序，如shift(),sort()连接件：⽅法的调⽤基本的计算模型：⼦程序有shift(), sort()⽅法，shift() 对单词进⾏移位，sort()⽅法对单词进⾏排序风格的基本不变性：主程序有顺序地调⽤⼦程序，单线程控制。
软件体系结构经典问题——KWIC的分析和解决
软件体系结构经典问题——KWIC的分析和解决KWIC作为⼀个早年间在ACM的Paper提出的⼀个问题，被全世界各个⼤学的软件设计课程奉为课堂讲义或者作业的经典。
（FromWiki，FYI，D. L. Parnas uses a KWIC Index as an example on how to perform modular design in his paper "On the Criteria To Be Used in Decomposing Systems into Modules" - Available as ACM Classic Paper）问题陈述：KWIC(Key Word In Context)，Parnas (1972)KWIC索引系统接受⼀些⾏，每⾏有若⼲字，每个字由若⼲字符组成；每⾏都可以循环移位，亦即重复地把第⼀个字删除，然后接到⾏末； KWIC把所有⾏的各种移位情况按照字母表顺序输出•⽬的：考察不同的体系结构对变化的适应能⼒（modifiab ility）•评价准则–处理算法的改变：例如，⾏的移位可在每⾏读⼊后、在所有⾏读⼊后、或当排序要求⼀组移位的⾏时執⾏；–数据表⽰的改变：例如，⾏、字、字符可以不同的⽅式存储；类似地，循环移位后的⾏可以显式或隐式存储（索引和偏移量）；–系统功能的增强：例如，限制以某些“修饰词”(a, an, and等)打头的移位结果；⽀持交互，允许⽤户从原始输⼊表中删除⼀些⾏等；–效率：时间和空间；–复⽤：构件被复⽤的潜⼒。
Solution 1：Main Program/Subroutine with Shared DataElements of Main/Subroutine Architectural style are:Components: FunctionsInteractions: Function callsPattern: Main function controls the calling sequenceThis is the primary organization of many software systems. This style reflects structural/procedural programming language (e.g. C programming language) in which these system are written.•Decompose the overall processing into a sequence of processing steps.–Read lines; Make shifts; Alphabetize; Print results•Each step transforms the data completely.每⼀步完全转换数据•Intermediate data stored in shared memory.–Arrays of characters with indexes带索引的字符数组–Relies on sequential processing串⾏处理Solution 1：Modularization•Module 1: Input–Reads data lines and stores them in “core”.–Storage format: 4 chars/machine word; array of pointers to start of each line.–•Module 2: Circular Shift–Called after Input is done.–Reads line storage to produce new array of pairs: (index of 1st char of each circular shift, index of original line)–•Module 3: Alphabetize–Called after Circular Shift.–Reads the two arrays and produces new index.•Module 4: Output–Called after alphabetization and prints nicely formatted output of shifts–Reads arrays produced by Modules 1 & 3–•Module 5: Master Control–Handles sequencing of the first 4 modules–Handles errorsProperties of Solution 1•Batch sequential processing.•Uses shared data to get good performance.⽤共享数据获得性能•Processing phases handled by control module.–So has some characteristics of main program – subroutine organization.–Depends critically on single thread of control.•Shared data structures exposed as inter-module knowledge.共享数据的结构是所有模块必须知道的–Design of these structures must be worked out before work can begin on those modules. 数据结构的设计必须在其他模块设计开始之前进⾏⽅案优缺点：+系统⾃然分解，符合⼈的处理习惯+数据共享，处理效率⾼+–难以适应数据存储格式和整体处理算法的变化——爲什麽？–系统构件难以⽀持复⽤——爲什麽？仔细参考：。
分析比较KWIC系统实现四种不同体系结构风格
分析比较KWIC系统实现四种不一样体系构造风格姓名：班级：学号：院系：一、试验目旳 (3)二、试验内容 (3)三、试验规定与试验环境 (3)四、试验操作 (3)1数据流风格：批处理序列；管道/过滤器 (3)2采用调用/返回风格：主程序/子程序、面向对象风格、层次构造 (5)3仓库风格：数据库系统、超文本系统、黑板系统 (7)4独立构件风格：进程通讯、事件系统 (8)五试验总结 (10)一、试验目旳通过KWIC 实例分析，理解和掌握软件体系构造风格设计与实现。
二、试验内容多种软件风格设计与实现KWIC 实例：1．采用主/子程序体系构造风格实现KWIC 关键词索引系统2．采用面向对象体系架构风格实现KWIC 关键词索引系统3．采用管道过滤体系架构风格实现KWIC 关键词索引系统4．采用事件过程调用体系架构风格实现KWIC 关键词索引系统三、试验规定与试验环境纯熟掌握基于主/子程序体系构造风格旳KWIC 关键词索引系统，在此基础上，完毕基于面向对象体系架构风格旳KWIC 关键词索引系统设计与实现。
选做基于管道过滤体系架构风格旳KWIC 关键词索引系统；选做基于事件过程调用体系架构风格旳KWIC 关键词索引系统。
四、试验操作1数据流风格：批处理序列；管道/过滤器管道-过滤器风格将系统旳功能逻辑建立为部件集合。
每个部件实例完毕一种对数据流旳独立功能处理，它接受数据流输入，进行转换和增量后进行数据流输出。
连接件是管道机制，它将前一种过滤器旳数据流输出传递给后一种过滤器作为数据流输入。
连接件也也许会进行数据流旳功能处理，进行转换或增量，但连接件进行功能处理旳目旳是为了适配前一种过滤器旳输出和后一种过滤器旳输入，而不是为了直接承载软件系统旳需求。
各个过滤器可以并发执行。
每个过滤器都可以在数据输入不完备旳状况下就开始进行处理，每次接到一部分数据流输入就处理和产生一部分输出。
这样，整个旳过滤器网络就形成了一条流水线。
分析比较KWIC系统实现四种不同体系结构风格
分析比较KWIC系统实现四种不同体系结构风格：班级：学号：院系：一、实验目的 (3)二、实验容 (3)三、实验要求与实验环境 (3)四、实验操作 (3)1数据流风格：批处理序列；管道/过滤器 (3)2采用调用/返回风格：主程序/子程序、面向对象风格、层次结构 (4)3仓库风格：数据库系统、超文本系统、黑板系统 (5)4独立构件风格：进程通讯、事件系统 (5)五实验总结 (6)一、实验目的通过KWIC 实例分析，理解和掌握软件体系结构风格设计与实现。
二、实验容多种软件风格设计与实现KWIC 实例：1．采用主/子程序体系结构风格实现KWIC 关键词索引系统2．采用面向对象体系架构风格实现KWIC 关键词索引系统3．采用管道过滤体系架构风格实现KWIC 关键词索引系统4．采用事件过程调用体系架构风格实现KWIC 关键词索引系统三、实验要求与实验环境熟练掌握基于主/子程序体系结构风格的KWIC 关键词索引系统，在此基础上，完成基于面向对象体系架构风格的KWIC 关键词索引系统设计与实现。
选做基于管道过滤体系架构风格的KWIC 关键词索引系统；选做基于事件过程调用体系架构风格的KWIC 关键词索引系统。
四、实验操作1数据流风格：批处理序列；管道/过滤器管道-过滤器风格将系统的功能逻辑建立为部件集合。
每个部件实例完成一个对数据流的独立功能处理，它接收数据流输入，进行转换和增量后进行数据流输出。
连接件是管道机制，它将前一个过滤器的数据流输出传递给后一个过滤器作为数据流输入。
连接件也可能会进行数据流的功能处理，进行转换或增量，但连接件进行功能处理的目的是为了适配前一个过滤器的输出和后一个过滤器的输入，而不是为了直接承载软件系统的需求。
各个过滤器可以并发执行。
每个过滤器都可以在数据输入不完备的情况下就开始进行处理，每次接到一部分数据流输入就处理和产生一部分输出。
这样，整个的过滤器网络就形成了一条流水线。
设计词汇表：Pipe, Filter构件和连接件类型构件：Filter连接件：Pipe例子：传统编译器优缺点：优点：易于理解并支持变换的复用。
软件设计模式与体系结构实验报告
软件设计模式与体系结构实验报告在软件开发的世界里，设计模式和体系结构就像调味料，给整个开发过程增添了无限风味。
你知道的，写代码有时候就像做饭，少了调料，味道肯定不行。
先说说设计模式吧，这可真是个绝佳的主意。
想象一下，咱们每次做个项目的时候，脑袋里总是要有个框架，知道怎么来、怎么走，这时候设计模式就像一个好老师，教我们如何优雅地解决常见问题。
说到这里，大家听说过单例模式吗？这个模式就像是“独一无二”的存在，确保你在整个应用中只有一个实例，这样可避免浪费资源，避免重复。
嘿，你敢想象要是你的冰箱里塞满了牛奶，那可真是够烦人的。
再聊聊策略模式，真是聪明的家伙。
就好比你在吃火锅，想换个口味，可以随时调换蘸料，策略模式就是给你提供了这种灵活性。
无论是要排序、计算还是处理数据，你都可以轻松切换。
这就像在生活中，不同的情况要有不同的应对方式。
生活本来就充满变化，代码也是一样嘛。
想到这里，我觉得代码和生活一样，得学会随机应变。
然后说到观察者模式，这可是个有趣的故事。
想象一下，你在看球赛，朋友们都在旁边紧盯着屏幕，眼神不离。
这就是观察者模式的精髓：一个对象变化，所有观察它的人都立刻得到通知，哇，这个效率可真高。
就像你在朋友圈发了条动态，大家立刻围过来评论点赞，简直不要太快。
这种模式让我们在编程中也能保持同步，绝对是个“跟得上”的好帮手。
再说到体系结构，嘿，这可是大事儿。
体系结构就像大楼的蓝图，如果没有好的设计，后面的施工就容易出问题。
想想看，你有没有见过那些盖得歪歪扭扭的楼？那可真是惨不忍睹。
一个好的体系结构可以让整个系统稳定运行，避免后期的各种麻烦，就像一部精密的机器，每个部分都得协同工作。
分层架构、微服务架构，这些概念都是在告诉我们，要有条理，别让代码变成“杂货铺”。
说到微服务架构，这可真是个炫酷的概念。
就好像把大块头的火锅分成一个个小锅，你想吃啥就来啥，各种口味应有尽有。
这种架构让开发变得灵活，团队可以独立开发，互不影响。
【精品实验报告】软件体系结构设计模式实验报告
【精品实验报告】软件体系结构设计模式实验报告软件体系结构设计模式实验报告学生姓名: 所在学院: 学生学号: 学生班级: 指导老师: 完成日期:一、实验目的熟练使用PowerDesigner和任意一种面向对象编程语言实现几种常见的设计模式，包括组合模式、外观模式、代理模式、观察者模式和策略模式，理解每一种设计模式的模式动机，掌握模式结构，学习如何使用代码实现这些模式，并学会分析这些模式的使用效果。
二、实验内容使用PowerDesigner和任意一种面向对象编程语言实现组合模式、外观模式、代理模式、观察者模式和策略模式，包括根据实例绘制模式结构图、编写模式实例实现代码，运行并测试模式实例代码。
(1) 组合模式使用组合模式设计一个杀毒软件(AntiVirus)的框架，该软件既可以对某个文件夹(Folder)杀毒，也可以对某个指定的文件(File)进行杀毒，文件种类包括文本文件TextFile、图片文件ImageFile、视频文件VideoFile。
绘制类图并编程模拟实现。
(2) 组合模式某教育机构组织结构如下图所示:北京总部教务办公室湖南分校行政办公室教务办公室长沙教学点湘潭教学点行政办公室教务办公室行政办公室教务办公室行政办公室在该教育机构的OA系统中可以给各级办公室下发公文，现采用组合模式设计该机构的组织结构，绘制相应的类图并编程模拟实现，在客户端代码中模拟下发公文。
(注:可以定义一个办公室类为抽象叶子构件类，再将教务办公室和行政办公室作为其子类;可以定义一个教学机构类为抽象容器构件类，将总部、分校和教学点作为其子类。
)(3) 外观模式某系统需要提供一个文件加密模块，加密流程包括三个操作，分别是读取源文件、加密、保存加密之后的文件。
读取文件和保存文件使用流来实现，这三个操作相对独立，其业务代码封装在三个不同的类中。
现在需要提供一个统一的加密外观类，用户可以直接使用该加密外观类完成文件的读取、加密和保存三个操作，而不需要与每一个类进行交互，使用外观模式设计该加密模块，要求编程模拟实现。
分析比较KWIC系统实现四种不同体系结构风格
分析比较KWIC系统实现四种不同体系结构风格KWIC系统（Keyword in Context）是一种文本处理系统，它通过对输入的文本进行预处理，将每个单词的关键字移到字母表序的最前面，从而方便用户查找和理解文本。
在实现KWIC系统的过程中，可以采用不同的体系结构风格。
本文将分析和比较KWIC系统实现的四种不同体系结构风格。
1.面向过程风格：面向过程风格是一种传统的体系结构风格，它以功能为中心，通过一系列的子程序来实现系统的功能。
在KWIC系统中，面向过程风格可以将各个功能模块划分为不同的子程序，如输入模块、处理模块和输出模块。
输入模块负责读取文本数据，处理模块负责对文本数据进行预处理，输出模块负责将处理后的文本数据进行显示或存储。
面向过程风格的优点是结构清晰，易于理解和维护。
然而，面向过程风格缺乏灵活性和可重用性，随着系统功能的扩展和变化，其复杂性和维护成本会增加。
2.面向对象风格：面向对象风格是一种基于对象和类的体系结构风格，它将系统划分为多个对象，每个对象都具有属性和方法。
在KWIC系统中，面向对象风格可以将输入、处理和输出等功能划分为不同的对象，对象之间通过消息传递来实现协作。
输入对象负责读取文本数据，处理对象负责对文本数据进行预处理，输出对象负责将处理后的文本数据进行显示或存储。
面向对象风格的优点是可重用性和灵活性强，易于扩展和维护。
然而，面向对象风格的缺点是易于产生过度设计和过度集成的问题，增加系统的复杂性和开发成本。
3.数据流风格：数据流风格是一种基于数据流和处理器之间的依赖关系的体系结构风格，它将系统看作一系列的数据流和处理器。
在KWIC系统中，数据流风格可以将输入、处理和输出等功能看作数据流，并将数据流之间的依赖关系表示为处理器的输入和输出。
处理器负责对输入的数据流进行处理，生成输出的数据流。
数据流风格的优点是模块化和并行化程度高，易于理解和调试。
然而，数据流风格的缺点是系统结构复杂，难以维护和扩展。
软件设计与体系结构实验报告
实验项目列表实验1：ACME软件体系结构描述语言应用一、实验目的1）掌握软件体系结构描述的概念2）掌握应用ACMESTUDIO工具描述软件体系结构的基本操作二、实验学时2学时。
三、实验方法由老师提供软件体系结构图形样板供学生参考，学生在样板的指导下修改图形，在老师的指导下进行软件体系结构描述。
四、实验环境计算机及ACMESTUDIO。
五、实验内容利用ACME语言定义软件体系结构风格，修改ACME代码，并进行风格测试。
六、实验操作步骤一、导入Zip文档建立的一个Acme Project，并且命名为AcmeLab2。
如下图：接着导入ZIP文档，导入完ZIP文档后显示的如下图：二、修改风格在AcmeLab2项目中,打开families下的TieredFam.acme.如下图：修改组件外观1. 在组件类型中，双击DataNodeT; 在其右边的编辑器中，将产生预览；选择Modify按钮，将打开外观编辑器对话框。
2. 首先改变图形：找到Basic shape section，在Stock image dropdown menu中选择Repository类型.3. 在Color/Line Properties section修改填充颜色为深蓝色。
4. 在颜色对话框中选择深蓝色，并单击[OK].5. 修改图形的边框颜色为绿色7. 单击Label tab，在Font Settings section, 设置字体颜色为白色,单击[OK] 产生的图形如下图：添加新元素类型1. 在Component Types section选择New按钮2. 在对话框中，类型名称输入LogicNodeT .3. 选择TierNodeT 为父类型.4. 单击[Finish].5. 按照修改外观的步骤，修改LogicNodeT的外观：填充颜色为浅绿色，边框颜色为黑色，大小为2，其他默认。
产生的图形如下图：添加新属性类型1. 选择Property Types2. 选择New按钮3. 在对话框中，类型名称为TierPropT4. 类型选择enum5. 值为：client, logic, data6. 单击[OK].添加属性1. 激活属性视图页2. 双击TierNodeT3. 选择Properties tab4. 右击空白位置，或者单击图标，选择新建属性5. 属性名为tier.6. 类型为TierPropT（找不到，则直接输入TieredFam.TierPropT）7.单击[OK].添加规则1. 单击Family editor中的TieredFam (Press to select).2. 选择属性视图中的规则页3. 单击生成新规则4. 规则名为hostCheck，选择invariant单选项5. 在规则框中输入（直接粘贴过去）Forall t1 : TierNodeT in ponents |!t1.allowShareHost -> (Forall t2 : TierNodeT in ponents | t1 != t2 -> t1.host != t2.host)6. 单击[Parse Rule] 以确认无语法错误，有错误，要重新写。
中南大学,软件体系结构实验报告
中南大学软件体系结构实验报告题目系统的用例模型+类模型+状态建模指导老师李祖德学生姓名孙毅学生学号 0906140106 学院信息科学与工程学院专业班级信安1401班完成时间 2016年11月30日目录实验一系统的用例模型 (1)一、实验目的 (1)二、实验器材 (1)三、实验内容 (1)四、实验步骤 (1)五、实验心得体会 (4)实验二系统的类模型 (6)一、实验目的 (6)二、实验器材 (6)三、实验内容 (6)四、实验步骤 (6)五、实验心得体会 (17)实验三系统的状态建模 (18)一、实验目的 (18)二、实验器材 (18)三、实验内容 (18)四、实验步骤 (18)五、实验心得体会 (22)实验一系统的用例模型实验名称：系统的用例模型实验类型: 设计性实验一、实验目的1．熟悉用例图的基本功能和使用方法。
2．锻炼结合给定题目，进行有效需求分析的能力。
3．掌握如何使用建模工具绘制用例图的方法。
二、实验器材1．计算机一台。
2．UML建模工具，StarUML。
三、实验内容在理解用例图的基本功能和使用方法的基础上，结合具体问题，完成对系统的需求建模，得到用例模型后，应针对每个用例进行业务分析，说明其具体的业务流程。
用Rational Rose 或StarUML工具软件绘制系统的用例图。
下文以Rational Rose为例讲解基本步骤。
四、实验步骤(1)在图中的工具栏选取Actor图标，在右边的图中添加一个Actor，并输入名称:administrator,如图1.1所示。
图1.1(2)在左边的工具栏中，选取用例的图标，在右边的图中画出一个用例，并输入用例的名称：login , 如图1.2所示。
图1.2(3)按照(2), 在右边的图中画出另外两个用例，并输入用例的名称：search，delete。
如图1.3所示。
(4) 在绘出了用例后，接下来的是绘制参与者与用例实现，如图1.4所示。
图1.4(5) 根据步骤(4)，同时完成如图1.5和图1.6。
实验二 用“4+1”视图描述体系结构
实验2用“4+1”视图描述体系结构
一、实验目的：
理解“4+1视图”建模思想，熟悉体系结构生命周期模型，掌握基于软件体系结构建模方法。
二、实验学时：2
三、实验内容及操作步骤：
（一）实验内容
根据“4+1”视图对KWIC（关键词索引系统）系统建模，完成KWIC系统的逻辑视图、过程视图、物理视图、开发视图和场景视图。
（二）操作步骤
基于“4+1”视图，对KWIC（关键词索引系统）系统进行视图建模：
1．建立KWIC的逻辑视图
采用面向对象的设计方法时，逻辑视图即是对象模型。
2．建立KWIC的过程视图
描述系统的并发和同步方面的设计。
3．建立KWIC的物理视图
描述软件到硬件之间的映射关系，反映系统在分布方面的设计。
4．建立KWIC的开发视图
描述软件在开发环境下的静态组织。
5．建立KWIC的场景视图描述软件体系结构的用例。
四、实验要求：
实验课前完成实验报告的实验目的、实验环境、实验内容、实验操作过程等内容；
实验课中独立/团队操作完成实验报告的实验操作、实验结果及结论等内容；每人一台PC机，所需软件Win2003/XP、UML工具（EclipseUML/ Rose/Visio/StartUML/）、Eclipse/MyEclipse、JDK6.0等。
实验课后完成实验报告的心得体会内容，并及时提交实验报告。
五、实验报告要求：
1．独立完成。
2．按时保质保量提交电子版和纸质版作业。
3．纸质版以班为单位上交，由班长负责收发；电子版作业文档以班为单位打包交给班长。
软件体系结构实验报告
学生实验报告（理工类）课程名称：软件体系结构专业班级：13软件工程2班学生学号： 1305104069 学生姓名：管东升所属院部：软件工程学院指导教师：陈圣国20 15 ——20 16 学年第 1 学期金陵科技学院教务处制实验报告书写要求实验报告原则上要求学生手写，要求书写工整。
若因课程特点需打印得，要遵照以下字体、字号、间距等得具体要求。
纸张一律采用A4得纸张。
实验报告书写说明实验报告中一至四项内容为必填项，包括实验目得与要求；实验仪器与设备；实验内容与过程；实验结果与分析。
各院部可根据学科特点与实验具体要求增加项目。
填写注意事项（1）细致观察，及时、准确、如实记录。
（2）准确说明，层次清晰。
（3）尽量采用专用术语来说明事物。
（4）外文、符号、公式要准确，应使用统一规定得名词与符号。
（5）应独立完成实验报告得书写，严禁抄袭、复印，一经发现，以零分论处。
实验报告批改说明实验报告得批改要及时、认真、仔细，一律用红色笔批改。
实验报告得批改成绩采用百分制，具体评分标准由各院部自行制定。
实验报告装订要求实验批改完毕后，任课老师将每门课程得每个实验项目得实验报告以自然班为单位、按学号升序排列，装订成册，并附上一份该门课程得实验大纲。
实验项目名称：经典软件体系结构风格实验学时： 4学时同组学生姓名：实验地点： 1216 实验日期： 2015、10、27-2015、11、3 实验成绩：批改教师：批改时间：一、实验目得与要求（1）理解管道-过滤器软件体系结构、面向对象软件体系结构得原理（2）掌握管道-过滤器软件体系结构、面向对象软件体系结构特点（3）面向对象软件体系结构得编程实现二、实验仪器与设备奔腾以上计算机，Windows 10 、Visual Studio 2013、MySQL三、实验过程（1）在dos下体会管道过滤器得体系结构。
使用 dir | more 命令了解管道-过滤器风格得程序。
（2）数据抽象与面向对象软件体系结构设计实现。
KWIC实验报告(C++)
软件体系结构上机实验报告书中国石油大学（）信息学院计算机科学与技术系制订人：周新学号：2008082207指导教师：朱雪峰博士2011年10月27日1、课程实验目的通过KWIC（Key Word in Context）检索系统，对软件体系结构有更加深入的了解和认识。
通过运用几种体系结构，熟悉常见的软件体系结构，并对这几种结构有进一步了解。
2、任务概述用管道过滤器，主程序、子程序，抽象数据类型，隐式调用这四种结构来分别实现KWIC检索系统。
3、实现方法用C++主要实现了两种结构：主程序、子程序结构，抽象数据类型。
（1）KWIC1工程的入口函数int _tmain(int argc, _TCHAR* argv[]){//界面，结构选择cout<<"Input a absolute filename:";char filename[30];cin>>filename;cout<<"Choose KWIC function"<<endl<<"1 is Main Program/Subroutine with Shared Data"<<endl<<"2 is Abstract Data Types"<<endl;int choose=0;cin>>choose;if(1==choose)//主程序和子程序{MainSubroutine mainSub;vector<vector<string> > lines=mainSub.readLines(filename);vector<LINE> lineIndex=mainSub.shiftString(lines);lineIndex=mainSub.firstAlphaSort(lineIndex,lines);mainSub.outPut(lineIndex,lines);}else//抽象收据类型{Lines *lines=new Lines;Input input;Shift *shift=new Shift;FirstAlphaSort alphaSort;Output output;input.readLines(filename,*lines);shift->circularShift(*lines);alphaSort.alphaSort(*shift);output.print(alphaSort);delete shift;delete lines;}return 0;}（2）主程序、子程序结构实现类//从文件中按行读取vector<vector<string> > MainSubroutine::readLines(char* filename){vector<vector<string> > dst;ifstream infile(filename,ios::in);if(!infile){cout<<"open error!"<<endl;exit(0);}char temp[100]="";//存储从文件中读取的行的临时变量//按行读取while(infile.getline(temp,100)){int k=0,j=0;vector<string> line;line.swap(vector<string>());char s[20]="";//存储从行中取字符串的临时变量while(temp[k]!=0){//每个单词的截取条件为下一个字符为空格或者为行的末尾if((temp[k+1]==' '||temp[k+1]==0)&&temp[k]!=' '){s[j]=temp[k];s[j+1]='\0';string ss=s;line.push_back(ss);j=0;}else if(temp[k]==' '){j=0;}else{s[j]=temp[k];j++;}k++;}dst.push_back(line);//将从文件中中读出的行加入到dst中}infile.close();for(int i=0;i<dst.size();i++){for(int j=0;j<dst.at(i).size();j++){cout<<dst[i][j]<<" ";}cout<<endl;}cout<<endl<<endl;return dst;}//循环左移vector<LINE> MainSubroutine::shiftString(vector<vector<string> > srcLines){vector<LINE> shiftLines;for(int row=0;row<srcLines.size();row++){int colnum=srcLines[row].size();//获取每一行的字符串个数//对第row行循环colnum（字符串个数）次，生成循环移位后的colnum 行for(int col=0;col<colnum;col++){LINE linePos;//声明存放一行的行标以及各列的列表的结构体linePos.rowIndex=row;//给行标赋值//循环生成一行的列标for(int colshift=0;colshift<colnum;colshift++){linePos.colIndex.push_back((col+colshift)%colnum);//取模运算}shiftLines.push_back(linePos);}}return shiftLines;}//字母排序vector<LINE> MainSubroutine::firstAlphaSort(vector<LINE> lineIndex,vector<vector<string> > srcLines){vector<vector<char> > firstChar;vector<LINE> dstIndex;for(int row=0;row<srcLines.size();row++){vector<char> firstCharLine;//逐行提取各个字符串的首字母for(int col=0;col<srcLines[row].size();col++){firstCharLine.push_back(srcLines[row][col][0]);}firstChar.push_back(firstCharLine);//}int rowPos=0;int colPos=0;//外面的两层for循环是控制循环次数的//部的两层for循环是遍历所有的字符串首字母，寻找最小的字母for(int row=0;row<firstChar.size();row++){for(int col=0;col<firstChar[row].size();col++){char min='z';for(int row=0;row<firstChar.size();row++){for(int col=0;col<firstChar[row].size();col++){if(min>=firstChar[row][col]&&''!=firstChar[row][col]){rowPos=row;colPos=col;min=firstChar[row][col];}}}firstChar[rowPos][colPos]=' ';int linePos=0;//在原行矩阵中的位置for(int line=0;line<rowPos;line++){linePos+=srcLines[line].size();}linePos=linePos+colPos;dstIndex.push_back(lineIndex[linePos]);}}return dstIndex;}//按照lineIndex中的字符串的行标和列标输出所有字符串void MainSubroutine::outPut(vector<LINE> lineIndex, vector<vector<string> > srcLines){for(int row=0;row<lineIndex.size();row++){for(int col=0;col<lineIndex[row].colIndex.size();col++){cout<<srcLines[lineIndex[row].rowIndex][lineIndex[row].colIndex[col]]<< " ";}cout<<endl;}cout<<endl;}（3）抽象数据类型结构实现行存储类//增加行//参数：line字符串向量列表void Lines::addLine(vector<string> line){lines.push_back(line);}//从存储结构中获取某一行//参数：lineIndex为获取的行的序号，从0开始//返回获取的行vector<string> Lines::getLine(int lineIndex){return lines[lineIndex];}// 增加字符串//参数：instring为所添加字符串，lineIndex为字符串所在行的序号（从0开始）void Lines::addString(string instring, int lineIndex){lines[lineIndex].push_back(instring);}//获取字符串//参数：lineIndex为行序号，stringIndex为字符串在行中的序号//返回获取的字符串string Lines::getString(int lineIndex,int stringIndex){return lines[lineIndex][stringIndex];}//增加字符//参数：inchar为增加的字符，stringIndex为增加的字符所在的字符串的序号，lineIndex为增加的字符所在的行的序号void Lines::addChar(char inchar, int stringIndex, int lineIndex){lines[lineIndex][stringIndex].push_back(inchar);}//获取字符//参数：lineIndex为行序号，stringIndex为字符串的序号，charIndex为字符的序号//返回获取的字符char Lines::getChar(int lineIndex, int stringIndex, int charIndex){return lines[lineIndex][stringIndex][charIndex];}//获取总的行数int Lines::getLineNum(void){return lines.size();}//获取特定行的字符串个数int Lines::getStringNum(int lineIndex){return lines[lineIndex].size();}输入类void Input::readLines(char* filename, Lines &readLines){// vector<vector<string> > dst;ifstream infile(filename,ios::in);if(!infile){cout<<"open error!"<<endl;exit(0);}char temp[100]="";//存储从文件中读取的行的临时变量int lineIndex=0;//行序号//按行读取while(infile.getline(temp,100)){int k=0,j=0;vector<string> line;line.swap(vector<string>());readLines.addLine(line);char s[20]="";//存储从行中取字符串的临时变量int stringIndex=0;//字符串序号readLines.addString(s,lineIndex);while(temp[k]!=0){if(temp[k]!=' '){readLines.addChar(temp[k],stringIndex,lineIndex);}//每个单词的截取条件为下一个字符为空格或者为行的末尾if(temp[k]==' '&&temp[k+1]!=' '){// readLines.addChar(temp[k],stringIndex,lineIndex);//将该字符串加入到指定行的指定字符串中// readLines.addChar('\0',stringIndex,lineIndex);s[0]='\0';//清空字符串readLines.addString(s,lineIndex);stringIndex++;//字符串序号加1}k++;}lineIndex++;// dst.push_back(line);//将从文件中中读出的行加入到dst中}infile.close();for(int i=0;i<readLines.getLineNum();i++){for(int j=0;j<readLines.getStringNum(i);j++){cout<<readLines.getString(i,j)<<" ";}cout<<endl;}cout<<endl<<endl;}循环左移类//实现所有行的循环移位void Shift::circularShift(Lines srcLines){int lineIndex=0;for(int row=0;row<srcLines.getLineNum();row++){int cols=srcLines.getStringNum(row);for(int col=0;col<cols;col++){vector<string> newLine;lineShift.addLine(newLine);for(int newcol=0;newcol<cols;newcol++){lineShift.addString(srcLines.getString(row,(col+newcol)%cols),lineIndex );}lineIndex++;}}}//获取所有行Lines Shift::getLines(void){return lineShift;}//获取某一行vector<string> Shift::getLine(int lineIndex){return lineShift.getLine(lineIndex);}//获取某一行中某一位置的字符串string Shift::getString(int lineIndex,int stringIndex){return lineShift.getString(lineIndex,stringIndex);}//获取某一行中某一个字符串中的某一位置的字符char Shift::getChar(int lineIndex, int stringIndex, int charIndex){return lineShift.getChar(lineIndex,stringIndex,charIndex);}//获取行数int Shift::getLineNum(void){return lineShift.getLineNum();}//获取某一行的字符串个数int Shift::getStringNum(int lineIndex){return lineShift.getStringNum(lineIndex);}排序类//实现按首字母排序void FirstAlphaSort::alphaSort(Shift srcShiftLines){shiftLines=srcShiftLines;//将传进得Shift对象赋值给成员变量vector<char> firstChar;for(int row=0;row<shiftLines.getLineNum();row++){firstChar.push_back(shiftLines.getChar(row,0,0));//获取首字母}//首字母排序for(int loop=0;loop<firstChar.size();loop++){char min='z';int rowIndex=0;for(int row=0;row<firstChar.size();row++){if(min>=firstChar[row]&&' '!=firstChar[row]){min=firstChar[row];rowIndex=row;}}charSort.push_back(rowIndex);firstChar[rowIndex]=' ';//将找到的最小的字母置为‘’，以便在下一次查找时不再保留}}//首字母排序vector<int> FirstAlphaSort::getCharSort(){return charSort;}//获取行数int FirstAlphaSort::getLineNum(void){return shiftLines.getLineNum();}//按行的序号，将各字符串合并成一个字符串，然后获取一行//lineIndex为行序号string FirstAlphaSort::getLineAsString(int lineIndex){string lineString;for(intstrCount=0;strCount<shiftLines.getStringNum(lineIndex);strCount++) {lineString+=shiftLines.getString(lineIndex,strCount)+" ";}lineString+="\0";return lineString;}输出类//按字母表顺序输出void Output::print(FirstAlphaSort sortLines){for(int row=0;row<sortLines.getLineNum();row++){cout<<sortLines.getLineAsString(sortLines.getCharSort()[row])<<endl;}cout<<endl;}4、实验的例程（1）主程序、子程序运行结果1选择的实现结构为主程序、子程序（2）抽象收据类型. .2选择的实现结构为抽象数据类型5、总结通过本次实验，首先对软件体系结构有了更真切的了解，尤其是对管道过滤器结构，主程序、子程序结构，抽象数据类型结构，隐式调用这四种结构的理解更加透彻了。
软件体系结构实验报告
软件体系结构实验报告软件体系结构实验报告引言：在当今信息技术高速发展的时代，软件已经成为各行各业的核心驱动力。
软件体系结构作为软件工程领域的重要概念之一，对于软件的设计和开发起着至关重要的作用。
本实验旨在通过对软件体系结构的研究和实践，深入了解软件体系结构的概念、原则和应用。
一、软件体系结构的概念软件体系结构是指软件系统的组织方式和结构框架，它描述了软件系统中各个组件之间的关系和相互作用。
软件体系结构的设计需要考虑到软件系统的功能需求、性能要求、可维护性等方面的因素。
一个好的软件体系结构应该具备模块化、可重用性、可扩展性等特点，能够满足软件系统的演化和变化。
二、软件体系结构的原则1. 分离关注点原则：将软件系统划分为多个模块，每个模块只关注特定的功能或责任，降低了模块之间的耦合度，提高了系统的可维护性和可扩展性。
2. 模块化原则：将软件系统划分为多个独立的模块，每个模块具有清晰的功能和接口，可以独立开发、测试和维护。
3. 层次化原则：将软件系统划分为多个层次，每个层次负责不同的功能和任务，层次之间通过接口进行通信和交互。
4. 组合原则：将不同的模块组合在一起，形成一个完整的软件系统，模块之间通过接口进行通信和交互，实现系统的功能。
三、软件体系结构的应用1. 分布式系统：分布式系统是由多个计算机节点组成的系统，节点之间通过网络进行通信和协作。
软件体系结构可以帮助设计和构建分布式系统的节点之间的通信和协作机制，提高系统的可靠性和性能。
2. 大型软件系统：大型软件系统通常由多个模块组成，每个模块负责不同的功能和任务。
软件体系结构可以帮助设计和构建大型软件系统的模块之间的关系和接口，提高系统的可维护性和可扩展性。
3. 嵌入式系统：嵌入式系统是指集成在其他设备中的软件系统，如手机、汽车等。
软件体系结构可以帮助设计和构建嵌入式系统的软件模块和硬件之间的接口，提高系统的性能和稳定性。
四、软件体系结构的实践在本次实验中，我们选择了一个实际的软件项目进行软件体系结构的设计和实践。
软件体系结构实验报告
软件体系结构实验报告一、实验目的本实验旨在通过实际操作，了解软件体系结构的概念、特点和原则，掌握软件体系结构的设计和实现方法。
二、实验内容1.搭建软件体系结构实验环境2.使用UML绘制软件体系结构图3.设计并实现一个简单的软件体系结构模型4.分析软件体系结构模型的优缺点以及适用场景三、实验步骤1.搭建软件体系结构实验环境2.使用UML绘制软件体系结构图我们使用UML（统一建模语言）来绘制软件体系结构图。
UML提供了一系列符号和规范，可以方便地描述软件系统的结构和行为。
我们首先需创建一个新的UML项目，并在此项目中绘制软件体系结构图。
3.设计并实现一个简单的软件体系结构模型我们选择一个简单的图书馆管理系统作为示例，用于展示软件体系结构的设计和实现。
首先，我们需要定义系统的各个模块及其功能，并在UML图中表示出来。
然后，我们使用Java语言来实现这些模块。
在实际编码过程中，我们需要注意模块之间的耦合度，以及模块之间的通信方式，这些都是影响软件体系结构的关键因素。
4.分析软件体系结构模型的优缺点以及适用场景在实现完软件体系结构模型后，我们需要对其进行评估。
我们可以从以下几个方面来评估软件体系结构模型的优劣：可维护性、可扩展性、性能、安全性等。
根据评估结果，我们可以得出软件体系结构模型是否满足我们的设计要求，以及是否适用于特定的场景。
四、实验结果通过本次实验，我们成功搭建了软件体系结构实验环境，并使用UML绘制了软件体系结构图。
在设计并实现一个简单的软件体系结构模型时，我们注意到模块之间的耦合度较高，需要进一步优化。
通过分析和评估软件体系结构模型，我们发现其具有较好的可维护性和可扩展性，适用于中小型图书馆管理系统。
五、实验总结通过本次实验，我们了解了软件体系结构的概念、特点和设计原则，并掌握了软件体系结构的设计和实现方法。
我们深入了解了UML的应用，能够使用UML绘制软件体系结构图。
通过设计和实现一个简单的软件体系结构模型，我们对软件体系结构的各个方面有了更深入的理解。
KWIC实验报告(C++)
软件体系结构上机实验报告书中国石油大学（北京）信息学院计算机科学与技术系制订人：周新学号：2008082207指导教师：朱雪峰博士2011年10月27日1、课程实验目的通过KWIC（Key Word in Context）检索系统，对软件体系结构有更加深入的了解和认识。
通过运用几种体系结构，熟悉常见的软件体系结构，并对这几种结构有进一步了解。
2、任务概述用管道过滤器，主程序、子程序，抽象数据类型，隐式调用这四种结构来分别实现KWIC检索系统。
3、实现方法用C++主要实现了两种结构：主程序、子程序结构，抽象数据类型。
（1）KWIC1工程的入口函数int _tmain(int argc, _TCHAR* argv[]){//界面，结构选择cout<<"Input a absolute filename:";char filename[30];cin>>filename;cout<<"Choose KWIC function"<<endl<<"1 is Main Program/Subroutine with Shared Data"<<endl<<"2 is Abstract Data Types"<<endl;int choose=0;cin>>choose;if(1==choose)//主程序和子程序{MainSubroutine mainSub;vector<vector<string> > lines=mainSub.readLines(filename);vector<LINE> lineIndex=mainSub.shiftString(lines);lineIndex=mainSub.firstAlphaSort(lineIndex,lines);mainSub.outPut(lineIndex,lines);}else//抽象收据类型{Lines *lines=new Lines;Input input;Shift *shift=new Shift;FirstAlphaSort alphaSort;Output output;input.readLines(filename,*lines);shift->circularShift(*lines);alphaSort.alphaSort(*shift);output.print(alphaSort);delete shift;delete lines;}return 0;}（2）主程序、子程序结构实现类//从文件中按行读取vector<vector<string> > MainSubroutine::readLines(char* filename){vector<vector<string> > dst;ifstream infile(filename,ios::in);if(!infile){cout<<"open error!"<<endl;exit(0);}char temp[100]="";//存储从文件中读取的行的临时变量//按行读取while(infile.getline(temp,100)){int k=0,j=0;vector<string> line;line.swap(vector<string>());char s[20]="";//存储从行中取字符串的临时变量while(temp[k]!=0){//每个单词的截取条件为下一个字符为空格或者为行的末尾if((temp[k+1]==' '||temp[k+1]==0)&&temp[k]!=' '){s[j]=temp[k];s[j+1]='\0';string ss=s;line.push_back(ss);j=0;}else if(temp[k]==' '){j=0;}else{s[j]=temp[k];j++;}k++;}dst.push_back(line);//将从文件中中读出的行加入到dst中}infile.close();for(int i=0;i<dst.size();i++){for(int j=0;j<dst.at(i).size();j++){cout<<dst[i][j]<<" ";}cout<<endl;}cout<<endl<<endl;return dst;}//循环左移vector<LINE> MainSubroutine::shiftString(vector<vector<string> > srcLines) {vector<LINE> shiftLines;for(int row=0;row<srcLines.size();row++){int colnum=srcLines[row].size();//获取每一行的字符串个数//对第row行循环colnum（字符串个数）次，生成循环移位后的colnum行for(int col=0;col<colnum;col++){LINE linePos;//声明存放一行的行标以及各列的列表的结构体linePos.rowIndex=row;//给行标赋值//循环生成一行的列标for(int colshift=0;colshift<colnum;colshift++){linePos.colIndex.push_back((col+colshift)%colnum);//取模运算}shiftLines.push_back(linePos);}}return shiftLines;}//字母排序vector<LINE> MainSubroutine::firstAlphaSort(vector<LINE> lineIndex,vector<vector<string> > srcLines){vector<vector<char> > firstChar;vector<LINE> dstIndex;for(int row=0;row<srcLines.size();row++){vector<char> firstCharLine;//逐行提取各个字符串的首字母for(int col=0;col<srcLines[row].size();col++){firstCharLine.push_back(srcLines[row][col][0]);}firstChar.push_back(firstCharLine);//}int rowPos=0;int colPos=0;//外面的两层for循环是控制循环次数的//内部的两层for循环是遍历所有的字符串首字母，寻找最小的字母for(int row=0;row<firstChar.size();row++){for(int col=0;col<firstChar[row].size();col++){char min='z';for(int row=0;row<firstChar.size();row++){for(int col=0;col<firstChar[row].size();col++){if(min>=firstChar[row][col]&&' '!=firstChar[row][col]){rowPos=row;colPos=col;min=firstChar[row][col];}}}firstChar[rowPos][colPos]=' ';int linePos=0;//在原行矩阵中的位置for(int line=0;line<rowPos;line++){linePos+=srcLines[line].size();}linePos=linePos+colPos;dstIndex.push_back(lineIndex[linePos]);}}return dstIndex;}//按照lineIndex中的字符串的行标和列标输出所有字符串void MainSubroutine::outPut(vector<LINE> lineIndex, vector<vector<string> > srcLines){for(int row=0;row<lineIndex.size();row++){for(int col=0;col<lineIndex[row].colIndex.size();col++){cout<<srcLines[lineIndex[row].rowIndex][lineIndex[row].colIndex[col]]<<" ";}cout<<endl;}cout<<endl;}（3）抽象数据类型结构实现行存储类//增加行//参数：line字符串向量列表void Lines::addLine(vector<string> line){lines.push_back(line);}//从存储结构中获取某一行//参数：lineIndex为获取的行的序号，从0开始//返回获取的行vector<string> Lines::getLine(int lineIndex){return lines[lineIndex];}// 增加字符串//参数：instring为所添加字符串，lineIndex为字符串所在行的序号（从0开始）void Lines::addString(string instring, int lineIndex){lines[lineIndex].push_back(instring);}//获取字符串//参数：lineIndex为行序号，stringIndex为字符串在行中的序号//返回获取的字符串string Lines::getString(int lineIndex,int stringIndex){return lines[lineIndex][stringIndex];}//增加字符//参数：inchar为增加的字符，stringIndex为增加的字符所在的字符串的序号，lineIndex为增加的字符所在的行的序号void Lines::addChar(char inchar, int stringIndex, int lineIndex){lines[lineIndex][stringIndex].push_back(inchar);}//获取字符//参数：lineIndex为行序号，stringIndex为字符串的序号，charIndex为字符的序号//返回获取的字符char Lines::getChar(int lineIndex, int stringIndex, int charIndex){return lines[lineIndex][stringIndex][charIndex];}//获取总的行数int Lines::getLineNum(void){return lines.size();}//获取特定行的字符串个数int Lines::getStringNum(int lineIndex){return lines[lineIndex].size();}输入类void Input::readLines(char* filename, Lines &readLines){// vector<vector<string> > dst;ifstream infile(filename,ios::in);if(!infile){cout<<"open error!"<<endl;exit(0);}char temp[100]="";//存储从文件中读取的行的临时变量int lineIndex=0;//行序号//按行读取while(infile.getline(temp,100)){int k=0,j=0;vector<string> line;line.swap(vector<string>());readLines.addLine(line);char s[20]="";//存储从行中取字符串的临时变量int stringIndex=0;//字符串序号readLines.addString(s,lineIndex);while(temp[k]!=0){if(temp[k]!=' '){readLines.addChar(temp[k],stringIndex,lineIndex);}//每个单词的截取条件为下一个字符为空格或者为行的末尾if(temp[k]==' '&&temp[k+1]!=' '){// readLines.addChar(temp[k],stringIndex,lineIndex);//将该字符串加入到指定行的指定字符串中// readLines.addChar('\0',stringIndex,lineIndex);s[0]='\0';//清空字符串readLines.addString(s,lineIndex);stringIndex++;//字符串序号加1}k++;}lineIndex++;// dst.push_back(line);//将从文件中中读出的行加入到dst中}infile.close();for(int i=0;i<readLines.getLineNum();i++){for(int j=0;j<readLines.getStringNum(i);j++){cout<<readLines.getString(i,j)<<" ";}cout<<endl;}cout<<endl<<endl;}循环左移类//实现所有行的循环移位void Shift::circularShift(Lines srcLines){int lineIndex=0;for(int row=0;row<srcLines.getLineNum();row++){int cols=srcLines.getStringNum(row);for(int col=0;col<cols;col++){vector<string> newLine;lineShift.addLine(newLine);for(int newcol=0;newcol<cols;newcol++){lineShift.addString(srcLines.getString(row,(col+newcol)%cols),lineIndex);}lineIndex++;}}}//获取所有行Lines Shift::getLines(void)return lineShift;}//获取某一行vector<string> Shift::getLine(int lineIndex){return lineShift.getLine(lineIndex);}//获取某一行中某一位置的字符串string Shift::getString(int lineIndex,int stringIndex){return lineShift.getString(lineIndex,stringIndex);}//获取某一行中某一个字符串中的某一位置的字符char Shift::getChar(int lineIndex, int stringIndex, int charIndex) {return lineShift.getChar(lineIndex,stringIndex,charIndex);//获取行数int Shift::getLineNum(void){return lineShift.getLineNum();}//获取某一行的字符串个数int Shift::getStringNum(int lineIndex){return lineShift.getStringNum(lineIndex);}排序类//实现按首字母排序void FirstAlphaSort::alphaSort(Shift srcShiftLines){shiftLines=srcShiftLines;//将传进得Shift对象赋值给成员变量vector<char> firstChar;for(int row=0;row<shiftLines.getLineNum();row++){firstChar.push_back(shiftLines.getChar(row,0,0));//获取首字母}//首字母排序for(int loop=0;loop<firstChar.size();loop++){char min='z';int rowIndex=0;for(int row=0;row<firstChar.size();row++){if(min>=firstChar[row]&&' '!=firstChar[row]){min=firstChar[row];rowIndex=row;}}charSort.push_back(rowIndex);firstChar[rowIndex]=' ';//将找到的最小的字母置为‘’，以便在下一次查找时不再保留}}//首字母排序vector<int> FirstAlphaSort::getCharSort(){return charSort;}//获取行数int FirstAlphaSort::getLineNum(void){return shiftLines.getLineNum();}//按行的序号，将各字符串合并成一个字符串，然后获取一行//lineIndex为行序号string FirstAlphaSort::getLineAsString(int lineIndex){string lineString;for(intstrCount=0;strCount<shiftLines.getStringNum(lineIndex);strCount++) {lineString+=shiftLines.getString(lineIndex,strCount)+" ";}lineString+="\0";return lineString;}输出类//按字母表顺序输出void Output::print(FirstAlphaSort sortLines){for(int row=0;row<sortLines.getLineNum();row++){cout<<sortLines.getLineAsString(sortLines.getCharSort()[row])<<endl;}cout<<endl;}4、实验的例程（1）主程序、子程序运行结果（2）抽象收据类型5、总结通过本次实验，首先对软件体系结构有了更真切的了解，尤其是对管道过滤器结构，主程序、子程序结构，抽象数据类型结构，隐式调用这四种结构的理解更加透彻了。
完成基于管道过滤器风格的KWIC实现
实验2：软件体系结构风格实现一、实验目的1）初步了解不同的体系结构风格2）掌握不同体系结构风格的实现二、实验学时4学时。
三、实验方法根据KWIC的描述，用所熟悉的语言，完成实验内容。
四、实验环境Windows7旗舰版 jdk1.6 Eclipse3.7.0五、实验内容2）完成基于管道过滤器风格的KWIC实现六、实验操作步骤1. KWIC描述：KWIC索引系统接受一些行，每行有若干字，每个字由若干字符组成；每行都可以循环移位。
重复地把第一个字删除，然后接到行末； KWIC 把所有行的各种移位情况按照字母表顺序输出。
完成基于管道过滤器风格的KWIC实现Main类package kwic_pipe;import java.io.File;import java.util.Scanner;public class Main {public static void main(String[] args) {File infile = new File("e:\\mykwic_in.txt");File outfile = new File("e:\\mykwic_out.txt");Scanner inputfile;Scanner outputfile;try{inputfile = new Scanner(infile);outputfile = new Scanner(outfile);// 定义三个管道Pipe pipe1 = new Pipe();Pipe pipe2 = new Pipe();Pipe pipe3 = new Pipe();// 定义四种过滤器Input input = new Input(infile, pipe1);Shift shift = new Shift(pipe1, pipe2);Output output = new Output(pipe3, outfile); // 启动四种过滤器的线程input.transform()shift. transform ();output. transform ();// 直接输出结果System.out.println("----- infile -----"); String str = null;while (inputfile.hasNextLine()){str = inputfile.nextLine();System.out.println(str);}System.out.println("input end");Thread.sleep(3000);System.out.println("----- outfile -----"); while (outputfile.hasNextLine()){System.out.println(str);}inputfile.close();outputfile.close();}catch (Exception e){e.getMessage();}}}Filter类package kwic_pipe;import java.io.IOException;public abstract class Filter {//定义输入管道protected Pipe input;//定义输出管道protected Pipe output;private boolean isStart = false;Filter(Pipe input, Pipe output){this.input = input;this.output = output;}// 防止多次调用，调用之后线程开始执行public void start(){if(!isStart){isStart = true;Thread thread = new Thread();thread.start();}}//线程的 run 方法public void run(){try{this.transform();} catch (IOException e){e.getMessage();}}//将输入数据转换为所需数据并写入输出管道//由子类实现抽象方法protected abstract void transform()throws IOException; }Pipe类package kwic_pipe;import java.io.IOException;import java.io.PipedReader;import java.io.PipedWriter;import java.io.PrintWriter;import java.util.Scanner;public class Pipe {//输入管道private Scanner pipereader;//输出管道private PrintWriter pipewriter;public Pipe(){PipedWriter pw = new PipedWriter();PipedReader pr = new PipedReader();try{pw.connect(pr);} catch (IOException e){e.getMessage();}pipewriter = new PrintWriter(pw);pipereader = new Scanner(pr);}//读入一行数据到管道//@return 读入的数据public String readerLine() throws IOException{return pipereader.nextLine();}//从管道输出一行数据public void writerLine(String strline) throws IOException{pipewriter.println(strline);}//将读管道关闭，调用该方法后，不能再从管道中读数据//如不能关闭则抛出异public void closeReader() throws IOException{pipereader.close();}//先刷新数据，在将写管道关闭，调用该方法后，不能向管道中写数据 //如不能关闭则抛出异常public void closeWriter() throws IOException{pipewriter.flush();pipewriter.close();}}Alphabetizer类package kwic_pipe;import java.io.IOException;import java.util.ArrayList;import java.util.Collections;public class Alphabetizer extends Filter{private ArrayList<String> al = new ArrayList<String>();Alphabetizer(Pipe input, Pipe output){super(input, output);}//对读入的数据进行排序protected void transform() throws IOException {String templine = null;//读入数据while((templine = input.readerLine()) != null){al.add(templine);}//按字母表排序Collections.sort(al);//对排序后的数据进行输出for(int i = 0; i < al.size(); i++){output.writerLine(al.get(i));}input.closeReader();output.closeWriter();}}Shift类package kwic_pipe;import java.io.IOException;import java.util.ArrayList;public class Shift extends Filter{//单词的列表private ArrayList<String> wordlist = new ArrayList<String>(); //重组后的行的列表private ArrayList<String> linelist = new ArrayList<String>();Shift(Pipe input, Pipe output){super(input, output);}@Overrideprotected void transform() throws IOException {String templine = "";//读数据while((templine = input.readerLine()) != null){//将数据拆分为不同单词this.lineSplitWord(templine);//将单词重组为句子this.recombination();//输出重组结果for(int i = 0; i < linelist.size(); i++){output.writerLine(linelist.get(i));}//清空wordlist、linelist和templinewordlist.clear();linelist.clear();templine = "";}input.closeReader();output.closeWriter();}//从一行中提取单词存入单词表中private void lineSplitWord(String line){String word = "";int i = 0;while(i < line.length()){if(line.charAt(i) != ' '){word += line.charAt(i);}else{wordlist.add(word);}i++;}}private void recombination(){for(int j = 0; j < wordlist.size(); j++){String templine = "";for (int k = wordlist.size() - 1 - j; k < wordlist.size(); k++){ templine += wordlist.get(k) + " ";}for (int m = 0; m < wordlist.size() - 1 - j; m++){if(m != wordlist.size() - j - 2){templine += wordlist.get(m) + " ";}else{templine += wordlist.get(m);}}linelist.add(templine);}}}Input类package kwic_pipe;import java.io.File;import java.io.IOException;import java.util.Scanner;public class Input extends Filter{//输入文件的文件名private File infile;Input(File file, Pipe output){super(null, output);this.infile = file;}@Override//读取数据protected void transform() throws IOException { Scanner sc = new Scanner(infile);String templine = "";while((templine = sc.nextLine()) != null){ output.writerLine(templine);}output.closeWriter();sc.close();}}Output类package kwic_pipe;import java.io.File;import java.io.IOException;import java.io.PrintWriter;public class Output extends Filter{//输出文件的文件名private File file;Output(Pipe input, File file){super(input, null);this.file = file;}//输出数据protected void transform() throws IOException {PrintWriter pw = new PrintWriter(file);String templine = "";while((templine = input.readerLine()) != null){ pw.write(templine);pw.write("\n");}pw.flush();pw.close();input.closeReader();}}实验结果：输入文件：输出文件：。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
..
.
内部实现的可修改性。因为面向对象式风格要求封装内部数据，隐藏内部实 现，所以它可以在不影响外界的情况下，变更其内部实现。
易开发、易理解、易复用的结构组织。面向对象式风格将系统组织为一系列 平等、自治的单位，每个单位负责自身的“正确性”，不同单位之间仅仅是通过 方法调用相连接，这非常契合模块化思想，能够建立一个易开发、易理解、易复 用的实现结构。
(1) 构件类型：对象 (2) 连接件的类型：为对象间的消息传递 KWIC 的面向对象程序体系结构风格示意图如下所示：
基本的计算模型： Input 模块从文本文件 input.txt 中一行一行读取单 Shift 模块用于将单词移位。 Sort 模块将单词进行排序。 Output 模块将最终结果写到文本文件 output.txt 中
主程序 main(), 子程序 shift(), sort() 方法，方法的调用，返回构件和连接件类 型：
..
.
构件：各类子程序，如 shift(),sort() 连接件：方法的调用基本的计算模型： 子程序有 shift(), sort()方法，shift() 对单词进行移位，sort()方法对单词进行 排序 风格的基本不变性： 主程序有顺序地调用子程序，单线程控制。 KWIC 的主/子程序体系结构风格示意图如下所示：
.
《软件体系结构》
实验：软件体系结构风格之应用
..
.
一、实验目的
通过 KWIC 实例分析，理解和掌握软件体系结构风格设计与实现。
二、实验内容
多种软件风格设计与实现之 KWIC 实例 ： 1．采用主/子程序体系结构风格实现 KWIC 关键词索引系统 2．采用面向对象体系架构风格实现 KWIC 关键词索引系统 3．采用管道过滤 体系架构风格实现 KWIC 关键词索引系统 4．采用事件过程调用体系架构风格实现 KWIC 关键词索引系统
..
.
● 子程序只能够通过上层转移来获得控制权，可以在执行中将控制权转交给 下层的子子程序，并在自身执行完成之后必须将控制权还交给上层部件。
KWIC 主程序/子程序风格的 Java 语言实现见附件。
主程序/子程序风格的主要实现机制是模块实现，它将每个子程序都实现为一 个模块，主程序实现为整个系统的起始模块。依照抽象规格的层次关系，实现模 块也被组织为相应的层次机构，通过导入/导出关系相连接。
采用面向对象体系结构风格实现 KWIC 关键词索引系统
面向对象式风格，需要强调说明的是它的“对象”是部件，属于高层结构的 元素，虽然名称相同，但它并不是面向对象方法中所述的“对象”实体。“面向 对象式”风格的命名是因为它借鉴了面向对象方法的思想，而不是因为它使用面 向对象方法实现体系结构，这也是在该风格名称中有一个“式”字的原因。
面向对象式风格的主要实现机制是模块实现，它将每个对象部件实例都实现 为一个模块。存在连接的对象部件实例之间会存在模块的导入/导出关系。
每个模块内部可以是基于面向对象方法的实现，也可以是基于结构化方法的 实现。
..
.
设计词汇表： (1) input, output, shift, sort, main 类 (2) shift, sort, output 对象 (3) 对象间的消息传递构件和连接件类型：
三、实验要求与实验环境
熟练掌握基于主/子程序体系结构风格的 KWIC 关键词索引系统，在此基础上， 完成基于面向对象体系架构风格的 KWIC 关键词索引系统设计与实现。选做基于 管道过滤体系架构风格的 KWIC 关键词索引系统；选做基于事件过程调用体系架 构风格的 KWIC 关键词索引系统。
实验课前完成实验报告的实验目的、实验环境、实验内容、实验操作过程等 内容；实验课中独立/团队操作完成实验报告的实验操作、实验结果及结论等内容； 每人一台 PC 机，所需软件 Win2003/XP 、 UML 工具（ EclipseUML/ Rose/Visio/StartUML/）、Eclipse/MyEclipse、JDK6.0 等。
3、采用管道和过滤器体系结构风格实现 KWIC 关键词索引系统
管道-过滤器风格将系统的功能逻辑建立为部件集合。每个部件实例完成一个 对数据流的独立功能处理，它接收数据流输入，进行转换和增量后进行数据流输 出。连接件是管道机制，它将前一个过滤器的数据流输出传递给后一个过滤器作 为数据流输入。连接件也可能会进行数据流的功能处理，进行转换或增量，但连 接件进行功能处理的目的为了适配前一个过滤器的输出和后一个过滤器的输入， 而不是为了直接承载软件系统的需求。
需要强调的是，虽然主程序/子程序风格非常类似于结构化程序的结构，但是 主程序/子程序风格是基于部件与连接件建立的高层结构。它的部件不同于程序， 而是更加粗粒度的模块。而且，在部件的实现模块内部，可以使用结构化方法， 也可以使用面向对象方法，这并不妨碍整个系统的高层结构符合主程序/子程序风 格的约定。
四、实验操作 1、采用主/子程序体系结构风格实现 KWIC 关键词索引系统
主程序/子程序风格（Main Program/Subroutine Style）将系统组织成层次结构， 包括一个主程序和一系列子程序。主程序是系统的控制器，负责调度各子程 序的执行。各子程序又是一个局部的控制器，调度其子程序的执行。 设计词汇表：
主程序/子程序风格的重要设计决策与约束有： ● 基于声明-使用（程序调用）关系建立连接件，以层次分解的方式建立系 统部件，共同组成层次结构。 ● 每一个上层部件可以“使用”下层部件，但下层部件不能“使用”上层部 件，即不允许逆方向调用。 ● 系统应该是单线程执行。主程序部件拥有最初的执行控制权，并在“使用” 中将控制权转移给下层子程序。
主程序/子程序风格的优点有： 流程清晰，易于理解。强控制性。严格的层次分解和严格的控制权转移使得 主程序/子程序风格对程序的实际执行过程具备很强的控制能力，这带来了一个特 点：如果一个子程序所连接的子子程序是正确的，那么就很容易保证该子程序的 “正确性”。所以，主程序/子程序风格比其他常见风格更能控制程序的“正确 性”。