嵌入式拼图游戏论文最终版
嵌入式拼图游戏
摘 要
拼图游戏是一种可变性很高且耐玩的游戏，在平时空闲的时候可以自己制定图片然后享受智力拼图，空闲之余不妨放松一下。拼图是一种大人与小孩都能玩的游戏，它可以开发智力且帮助大家提高动脑解决问题的能力。玩拼图还有助于手眼协调，玩家能训练和了解“部分”与“全部”的关系，可以知道许多的“部分”能拼凑出一个“全部”，以及一个“全部”是由许多“部分”所组成的。
本课题主要是在Linux环境下用嵌入式C语言及QT对一小型游戏进行开发。选择一个游戏的拼图图片，单击方框可使图片移动，从而能够拼出一幅完整的图片，这类游戏主要考察玩家的反应能力，在游戏之余提高观察和应变能力。
本游戏中通过分析C游戏的开发流程，对功能进行设计。该游戏主要实现了开始游戏，更改图片，游戏难度选择(9宫初级，16宫中级和25宫高级)，战况成绩统计，成绩排名，背景音乐等功能。游戏界面美观，操作简单，功能齐全，是广大游戏爱好者都喜欢的一款游戏，具有一定的复杂性和可玩性。
关键词:拼图游戏;嵌入式;Linux;QT
i
Embedded puzzle game
Abstract
Puzzle game is a kind of high variability and playable game, in the usual idle time can develop their own pictures and enjoy intellectual puzzles, more than the idle wish to relax. Jigsaw is an adults and children can play the game, it can develop intelligence and ability to help people improve their brains to solve problems. Puzzles also help hand-eye coordination, players can train and learn "some" relationship with the "All", you can know that many "parts" can piece together an "All", as well as an "All" is composed of many "partial" composed.
The main subject is embedded in the Linux environment using C language and QT for a small game development. Select a picture puzzle game, click the box to make the picture move, which can spell a complete picture, mainly on the type of game the players ability to respond to observe and improve the resilience of the remaining games.
By analyzing this game C game development process, functional design. The main achievement of the game to start the game, change the image, select game difficulty (9 Palace beginner, 16 intermediate and 25 Palace Palace senior), fighting performance statistics, standings, background music and other functions. Game beautiful interface, easy operation, complete functions, is the majority of gamers like a game, with a certain complexity and playability.
Key words: puzzle game;Embedded ; Linux;QT
ii
目 录
摘 要................................................................................................................................................... i
Abstract ................................................................................................................................................ ii
1 前言................................................................................................................................................ 1
1.1项目的目的与意义................................................................................................................ 1
1.2系统开发方法介绍................................................................................................................ 1
1.3本文结构................................................................................................................................ 3 2 项目开发语言及开发环境............................................................................................................ 4
2.1 C语言 .................................................................................................................................... 4
2.1.1设计特性..................................................................................................................... 4
2.1.2高效性......................................................................................................................... 4
2.1.3可移植性..................................................................................................................... 5
2.1.4强大的功能和灵活性................................................................................................. 5
2.1.5面向编程人员............................................................................................................. 5
2.1.6缺点............................................................................................................................. 5
2.2开发环境................................................................................................................................ 6
T Creator ............................................................................................................................. 6 2.3 Q
2.4 嵌入式开发........................................................................................................................... 6 3 可行性分析.................................................................................................................................... 8
3.1可行性分析所采用的方法和步骤........................................................................................ 8
3.2可行性分析............................................................................................................................ 8
3.3稳定性.................................................................................................................................... 9
4 总体设计...................................................................................................................................... 10
4.1功能需求.............................................................................................................................. 10
4.2总体设计
方案
气瓶 现场处置方案 .pdf气瓶 现场处置方案 .doc见习基地管理方案.doc关于群访事件的化解方案建筑工地扬尘治理专项方案下载
...................................................................................................................... 10
4.3系统流程设计...................................................................................................................... 11
4.4功能模块设计...................................................................................................................... 12 5 详细设计...................................................................................................................................... 15
5.1关键算法的设计与实现...................................................................................................... 15
5.1.1图片随机分割问题................................................................................................... 16
5.1.2判断图片是否可以交换........................................................................................... 21
................................................................................... 22 5.1.3更改图片................................
5.2模块命名规则...................................................................................................................... 23
5.3 QSS文件 ............................................................................................................................. 26
5.4 用户界面快照设计概述..................................................................................................... 27
6 软件测试...................................................................................................................................... 29
6.1测试的目的及相关问题...................................................................................................... 29
6.2测试方法.............................................................................................................................. 30
6.3部分测试用例...................................................................................................................... 32
6.3.1拼图测试................................................................................................................... 32
6.3.2游戏难度测试........................................................................................................... 32
6.3.3拼图游戏窗体外观测试........................................................................................... 33
6.4测试分析和总结.................................................................................................................. 33
结 论............................................................................................................................................ 35
参考文献............................................................................................................................................ 37
致 谢............................................................................................................................................ 38
外文原文............................................................................................................................................ 39
中文原文............................................................................................................................................ 50
1 前言
1.1项目的目的与意义
现代科学技术的发展，改变了人类的生活，作为新世纪的大学生，应该站在时代发展的前沿，掌握最先进的现代科学技术知识，以适应社会的发展，应能够独立地完成各种应要面临的任务，成为一名有创新意识的新型人才。
目前，很多技术领域依旧都涉及到了C语言。C语言是面向过程编程，并涉及到网络、多线程等重要的基础知识。该课题的主要目的是使C游戏开发者深入理解所学的C语言，并实践于该游戏设计中，深刻体会以前所学的有关C程序设计方面的语言基础、事件处理、应用程序以及图形用户界面设计等方面的知识，加深对结构化设计思想的理解，能对系统功能进行分析，并设计合理的结构等。学会使用C系统，其中包括对程序的调试、运行、保存等知识的运用，还包括提高程序开发功能，能运用合理的方法简化C程序的操作,开发过程中应培养分析问题、解决问题的能力。
基于QT组件技术的拼图游戏软件是一款具有娱乐性、益智性、便捷性的游戏软件。此软件可以使用户放松心情，享受于拼图游戏的乐趣之中。该游戏软件可以让用户选择适合自己的主题与难度，根据用户的不同水平，锻炼其图片记忆能力以及拼凑还原能力。游戏结束后亦可让用户清晰了解到自己的游戏状态水平，便于调整自己对这款游戏的新的难度要求。另外要求软件设计精致，画面亲和，人机交互高效快捷，能够给用户带来人性化的服务。软件面向的主流群体集中在儿童，但也适宜青年人或者老人使用，提供了适宜各类用户群体的图片风格与难度设置。不论是旨在轻松娱乐，还是益智教育的目的，该软件都是一款家庭生活中以及学习生活的必备软件。
设计并实现基于QT组件技术的拼图游戏软件作为自己的毕业课题设计是对学校基础课程、专业课程以及实践课程的一次综合性考查，旨在通过此次实践环节的训练，使我们能够更加全面地掌握 游戏设计的整体策划以及系统地掌握游戏设计的体系结构。通过 对我们所做游戏进行的类型确定、前期分析、整体策划以及设计 制作过程中所涉及的相关技术的学习和掌握，提高了我们的实践能力，为我们在计算机技术的应用上拓宽了道 路，对进入游戏设计这一领域的深入研究做了准备。此外，QT组件在界面开发上的应用一直处于热门，这次的系统全面的实践可以说是一次很好的锻炼，会对以后工作生活带来积极的影响。
1.2系统开发方法介绍
目前比较成熟的系统开发方法有:生命周期法、原型法、面向对象法等。
生命周期法:把一个信息系统从其提出、分析、设计和使用，直到停止使用的整个生存期视为一个生命周期。整个生命周期划分为五个主要工作阶段:可行性分析阶段、系统分析阶段、系统设计阶段、系统实施阶段和系统运行、维护与评价阶段。通常采用结构化系统分析和系统设计方法，自上而下分析、设计，强调开发过程的整体性和全局
1
性;开发过程在时间上基本按阶段进行，任务明确;结合用户需求进行开发;开发周期长，维护不方便。适用于开发需求较明确固定的信息系统。
“结构化分析方法(Structured Method，结构化方法)是面向过程的程序设计的方法，是强调开发方法的结构合理性以及所开发软件的结构合理性的软件开发方法。结构是指系统内各个组成要素之间的相互联系、相互作用的框架。结构化开发方法提出了一组提高软件结构合理性的准则，如分解与抽象、模块独立性、信息隐蔽等。针对软件生存周期各个不同的阶段，它有结构化分析(SA)、结构化设计(SD)和结构化程序设计(SP)等方法。
结构化分析方法给出一组帮助系统分析人员产生功能规约的原理与技术。它一般利用图形表达用户需求，使用的手段主要有数据流图、数据字典、结构化语言、判定表以及判定树等。
原型法:是系统开发者在初步了解用户需求的基础上，开发出能实现系统最基本功能的一个原型，再根据用户对原型使用与评价的意见，提出修改方案，修改完善原型，如此反复多次，直到得到用户满意的最终系统为止。开发过程以用户为中心，开发周期短。适用于开发需求不够明确或不断变化的软件。
面向对象方法(Object-Oriented Method)是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法，简称OO (Object-Oriented)方法，是建立在“对象”概念基础上的方法学。对象是由数据和容许的操作组成的封装体，与客观实体有直接对应关系，一个对象类定义了具有相似性质的一组对象。而每继承性是对具有层次关系的类的属性和操作进行共享的一种方式。所谓面向对象就是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界和设计、构建相应的软件系统。
面向过程方法的开发过程:
分析当前的情况，做出反映当前物理模型的DFD;
推导出等价的逻辑模型的DFD;
设计新的逻辑系统，生成数据字典和基元描述;
建立人机接口，提出可供选择的目标系统物理模型的DFD;
确定各种方案的成本和风险等级，据此对各种方案进行分析;
选择一种方案;
建立完整的需求规约。
面向对象方法的开发过程:
分析确定在问题空间和解空间出现的全部对象及其属性;
确定应施加于每个对象的操作，即对象固有的处理能力;
分析对象间的联系，确定对象彼此间传递的消息;
设计对象的消息模式，消息模式和处理能力共同构成对象的外部特性;
分析各个对象的外部特性，将具有相同外部特性的对象归为一类，从而确定所需要的类;
确定类间的继承关系，将各对象的公共性质放在较上层的类中描述，通过继承来共享对公共性质的描述;
设计每个类关于对象外部特性的描述;
设计每个类的内部实现(数据结构和方法);
创建所需的对象(类的实例)，实现对象间应有的联系(发消息)。
2
1.3本文结构
本文第一部分主要以前言为主，说明了文章的研究背景、主要工作，概要说明了所做的工作。第二部分主要是C语言以及相应开发工具的相关知识介绍，介绍了C语言，开发环境，QT Creator。第三部分叙述了设计可行性。第四部分为总体设计，包括了功能需求，总体设计方案，系统流程设计，功能模块的设计。第五部分为详细设计，包括设计当中涉及到的相关算法，模块命名，系统快照。第六部分为测试部分，包括了所涉及的测试用例，测试方法。
3
2 项目开发语言及开发环境
2.1 C语言
C语言是一种计算机程序设计语言，它既具有高级语言的特点，又具有汇编语言的特点。它由美国贝尔实验室的Dennis M. Ritchie于1972年推出，1978年后，C语言已先后被移植到大、中、小及微型机上，它可以作为工作系统设计语言，编写系统应用程序，也可以作为应用程序设计语言，编写不依赖计算机硬件的应用程序。它的应用范围广泛，具备很强的数据处理能力，不仅仅是在软件开发上，而且各类科研都需要用到C语言，适于编写系统软件、三维、二维图形和动画，具体应用例如单片机以及嵌入式系统开发。
2.1.1设计特性
C是一种融合了控制特性的现代语言，而在计算机科学的理论与实践中，控制特性是很重要的。其设计使得用户可以自然地采用自顶而下的规划、结构化的编程，以及模块化的设计。这种做法使得编写出的程序更可靠、更易懂。
C语言是种通用的、面向过程的程序语言。它具有高效、灵活、功能丰富、表达力强和较高的移植性等特点，在程序员中备受青睐。下面只介绍了c语言最容易理解的一般特点，由于C语言的这些优点，使c语言应用面很广。
2.1.2高效性
C是一种高效的语言。在设计上它充分利用了当前计算机在能力上的优点。C程序往往很紧凑且运行速度快。事实上，C可以表现出通常只有汇编语言才具有的精细的控制能力。如果愿意，可以细调程序以获得最大的速度或最大的内存使用率。
C语言的数据类型有整型、实型、字符型、数组类型、指针类型、结构体类型、共用体类型等。这些数据类型能用来实现各种复杂的数据结构(如链表、树、栈等)的运算，尤其是指针类型数据，使用起来比趴sc从更为灵活、多样;c语言的运算符包含的范围很广，共有34种运算符。c把括号、赋值、强制类型转换等都作为运算符处理，从而使c的运算类型极其丰富，表达式类型多样化。灵活使用各种运算符可以实现在其他高级语言中难以实现的运算。
C语言的一个语句可完成多项操作，一个表达式也可以完成多项操作。书写简练，源程序短，因而输入程序工作量小。
4
2.1.3可移植性
C是一种可移植语言。这意味着，在一个系统上编写的C程序经过很少改动或不经修改就可以在其他系统上运行。如果修改是必须的，则通常只须改变伴随主程序的一个头文件中的几项内容即可。C在可移植性方面处于领先地位。C编译器在大约40中系统上可用，包括从使用8位微处理器的计算机到Cary超级计算机。不过，程序中为访问特定硬件设备或操作系统的特殊功能而专门编写的部分，通常是不能移植的。
由于C与UNIX的紧密联系，UNIX系统通常都带有一个C编译器作为程序包的一部分。Linxu中同样也包括一个C编译器。个人计算机，包括运行不同版本的Windows和Macintosh的PC，可使用若干种C编译器。所以不论使用的是家用计算机、专业工作站还是大型机，都很容易得到对您的特定系统的C编译器。
2.1.4强大的功能和灵活性
C强大而又灵活。例如强大而灵活的UNIX操作系统的大部分便是C编写的。其他语言(如FORTANT、Perl、Python、Pascal、LISP、Logo和BASIC)的许多编译器和解释器也都是C编写的。
C程序一般只比汇编程序生成的目标代码的执行效率低10,一20,(却比其他高级语言的执行效率高。 c语言的移植性好。主要表现在只要对这种语言稍加修改，使可以适应个向型号的机器或各类操作系统。
2.1.5面向编程人员
C面向编程人员的需要。它允许您访问硬件，并可以操纵内存中的特定位。它具有丰富的运算符供选择，能够简洁地表达自己的意图。在限制所能做的事情方面，C不如Pascal这样的语言严格。这种灵活性是优点，同时也是一种危险。优点在于:许多任务在C中都简单的多。危险在于:使用C时，可能会犯在使用其他语言时不会犯的错误。C给予更多的自由，但同时也会承担更大的风险。
另外，多数C实现都有一个大型的库，其中包含有用的C函数。这些函数能够处理编程人员通常面对的许多需求。
2.1.6缺点
C也有一些缺点，如C在表达自由方便的自由会增加风险。尤其是C对指针的使用，意味着可能会犯难以追踪的编程错误。C的简洁性与丰富的运算符相结合，使其可能会编写出极难理解的代码。
5
2.2开发环境
操作系统:Ubuntu 12.0.1
处理器:Pentium(R) Dual-Core CPU E6300 @ 2.8GHz 2.8GH
安装内存(RAM): 2.00GB
编译器:minGW移植到windows下的gcc编译器
调试器:minGW移植到windows下的gdb调试器
Make:minGW中的mingw32-make
Qt C++ GUI
2.3 QT Creator
Qt Creator是跨平台的 Qt IDE， Qt Creator 是 Qt 被 Nokia 收购后推出的一款新的轻量级集成开发环境(IDE)。此 IDE 能够跨平台运行，支持的系统包括 Linux(32 位及 64 位)、Mac OS X 以及 Windows。根据官方描述，Qt Creator 的设计目标是使开发人员能够利用 Qt 这个应用程序框架更加快速及轻易的完成开发任务。
Qt Creator 包括项目生成向导、高级的 C++ 代码编辑器、浏览文件及类的工具、集成了 Qt Designer、Qt Assistant、Qt Linguist、图形化的 GDB 调试前端，集成 qmake 构建工具等。
QtCreator 主要是为了帮助新 Qt 用户更快速入门并运行项目，还可提高有经验的 Qt 开发人员的工作效率。语法标识和代码完成功能输入时进行静态代码检验以及提示样式上下文相关的帮助代码折叠括号匹配和括号选择模式高级编辑功能。集成了领先的版本控制软件，包括 Git、Perforce 和 Subversion开放式文件，无须知晓确切的名称或位置搜索类和文件跨不同位置或文件沿用符号在头文件和源文件，或在声明和定义之间切换集成了特定于 Qt 的功能，如信号与槽 (Signals & Slots)图示调试器， 对 Qt 类结构可一目了然集成了 Qt Designer 可视化布局和格式构建器只需单击一下就可生成和运行 Qt 项目。
2.4 嵌入式开发
嵌入式系统无疑是当前最热门最有发展前途的IT应用领域之一。嵌入式系统用在一些特定专用设备上，通常这些设备的硬件资源(如处理器、存储器等)非常有限，并且对成本很敏感，有时对实时响应要求很高等。特别是随着消费家电的智能化，嵌入式更显重要。像我们平常见到的手机、PDA、电子字典、可视电话、VCD/DVD/MP3 Player、数字相机(DC)、数字摄像机(DV)、U-Disk、机顶盒(Set Top Box)、高清电视(HDTV)、游戏机、智能玩具、交换机、路由器、数控设备或仪表、汽车电子、家电控制系统、医疗仪器、航天航空设备等等都是典型的嵌入式系统。
嵌入式系统是用来控制或者监视机器、装置、工厂等大规模设备的系统。嵌入式系统以应用为中心、以计算机技术为基础、软硬件可裁剪、功能、可靠性、成本、体积、
6
功耗严格要求的专用计算机系统。嵌入式系统是一种专用的计算机系统，作为装置或设备的一部分。通常，嵌入式系统是一个控制程序存储在ROM中的嵌入式处理器控制板。事实上，所有带有数字接口的设备，如手表、微波炉、录像机、汽车等，都使用嵌入式系统，有些嵌入式系统还包含操作系统，但大多数嵌入式系统都是由单个程序实现整个控制逻辑。
嵌入式开发一般具有以下特点:
可裁剪性。支持开放性和可伸缩性的体系结构。
强实时性。EOS实时性一般较强，可用于各种设备控制中。
统一的接口。提供设备统一的驱动接口。
操作方便、简单、提供友好的图形GUI和图形界面，追求易学易用。
提供强大的网络功能，支持TCP/IP
协议
离婚协议模板下载合伙人协议 下载渠道分销协议免费下载敬业协议下载授课协议下载
及其他协议，提供TCP/UDP/IP/PPP协议支持及统一的MAC访问层接口，为各种移动计算设备预留接口。
强稳定性，弱交互性。嵌入式系统一旦开始运行就不需要用户过多的干预、这就要负责系统管理的EOS具有较强的稳定性。嵌入式操作系统的用户接口一般不提供操作命令，它通过系统的调用命令向用户程序提供服务。
固化代码。在嵌入式系统中，嵌入式操作系统和应用软件被固化在嵌入式系统计算机的ROM中。
更好的硬件适应性，也就是良好的移植性。
嵌入式系统和具体应用有机地结合在一起，它的升级换代也是和具体产品同步进行，因此嵌入式系统产品一旦进入市场，具有较长的生命周期。
7
3 可行性分析
3.1可行性分析所采用的方法和步骤
可行性分析是通过对项目的主要内容和配套条件，如市场需求、资源供应、建设规模、工艺路线、设备选型、环境影响、资金筹措、盈利能力等，从技术、经济、工程等方面进行调查研究和分析比较，并对项目建成以后可能取得的财务、经济效益及社会环境影响进行预测，从而提出该项目是否值得投资和如何进行建设的咨询意见，为项目决策提供依据的一种综合性的系统分析方法。可行性分析应具有预见性、公正性、可靠性、科学性的特点。
我国可行性研究存在的主要问题，一是工程技术方案的研究论证深度不够。按照国外的通常做法，可行性研究阶段的研究深度应能达到定方案的程度，因此要求在工程技术方案论证，应达到Basic Design或Concept Design的程度，基本相当于我国的初步设计应达到的水平，应提出明确的设备清单;二是财务评价就项目论项目，这与国外利用企业理财的理论和方法进行资本预算管理，对投资项目进行投资决策和融资决策的通行做法存在重大差异，并且在经济评价方面不恰当地使用了"国民经济评价"的概念，由此引起一系列的认识误区;三是在市场分析、组织机构分析等方面与国外差别较大，研究深度严重不足;四是不重视多方案的比选及项目风险分析，或者分析的内容、深度严重不足，缺乏项目周期各阶段风险管理的统一筹划及策略论证。
通过研究分析拼图游戏所具备的能力及实现的方法来确定主体结构。利用现阶段我所能达到的能力，以最简洁、最容易的办法，边开发边测试边修改，实现一个初级游戏软件。
3.2可行性分析
由于本游戏是毕业设计，不过分强调直接的经济效益和其日后的发展方向，只在注重自身水平和能力的提高，同时对自身的经济要求也不高，只要有一台能运行Java软件的电脑便可，所以基本上不用考虑到经济问题。
可用与本游戏的编程语言有VB，Java，C等，考虑到用于编写程序的困难度，和对语言的了解程度，选择C作为编程语言。需要对变量定义、变量初始化、界面初始化、游戏初始化、然后进入游戏、处理游戏过程中的各种操作。
本游戏的开发作为毕业设计，目的在于巩固先前所学的知识，以个人为单位，仅供个人平常娱乐所用，无须考虑社会影响，不用考虑法律、版权等社会因素，且此软件的开发不触犯法律，所以在这方面是完全可行的。
8
3.3稳定性
现在做出来的只是一个拼图游戏的核心部分，这些代码经过许多测试和修改稳定性也比较强了。
开始时鼠标单击会选中拼图区之外的图块，经过修改后鼠标不会选中拼图区之外的任何部分，map映射数组和selected结构在使用前都需要经过测试保证其正确，然后才使用的。保证map数组不会出现越界错误，map数组和selected结构不会存入不正确的数据。这些都是经过测试通过了的。
鼠标单击图块边缘时选中的图块也是经过精确的计算的到，不会出现单击图块边缘时明明是单击的这个图块，却由于计算偏差选中了另一个图块。这些精确的计算也都是通过了软件的精确性测试通过了的。
9
4 总体设计
即对有关系统全局问题的设计，也就是设计系统总的处理方案，又称系统概要设计。它包括:计算机配置设计、系统模块结构设计、数据库和文件设计、代码设计以及系统可靠性与内部控制设计等内容。软件功能分解属于下列软件开发中的总体设计阶段。
它包括:计算机配置设计、系统模块结构设计、数据库和文件设计、代码设计以及系统可靠性与内部控制设计等内容。软件功能分解属于下列软件开发中的总体设计阶段。
4.1功能需求
用户对于该拼图游戏软件的需求主要体现在以下几个功能:
1. 实现程序GUI图形界面;
2. 实现游戏开始、退出等功能;
3. 实现鼠标或键盘事件响应模块的功能;
4. 实现可选难度等级功能;
5. 实现输赢自动判别功能;
6. 实现游戏图片更换功能;
7. 实现进行游戏同时可以查看原图功能;
8. 实现游戏内图片更换、重玩、返回界面、退出功能;
4.2总体设计方案
在开始游戏界面后，设计本程序能够载入默认图片(用户也可以选择想要的其它图片)，程序默认难度为9宫格(用户也可以选择想要的其他难度)，还设计实现背景音乐的播放功能等。在本程序中，对于图片的分割、拼凑、判断图片是否可以移动等都是设计的关键。总体设计方案中主要说明前期工作中对于分割图片以及判断拼图是否成功这两点的设计。
对于分割图片是用像素点来实现的，同时对图片进行了自动缩放，这样一来就可以使得图片分割后看起来更连贯。拆分图片后，把分好的图片存储到一个image数组中，对于可移动的块其实是按钮，每个按钮上都有一个icon，通过随机把image数组中的图片通过imageIcon的转化后附给一个按钮，并将按钮数组首先附给一个向量，然后用随机数来确定对应向量的值，然后再附给对应数组按钮，同时去除该值。也就是说在附值的时候图片顺序不变，变的而是数组按钮的顺序。
对于图片的是否拼图成功的提示，主要是在每个按钮中加个String的属性值，而且对于正确的排序的值与正在排的各个值比较，一旦所有的按钮对应的值与正确的排序一致，则为成功。
10
4.3系统流程设计
图4-1流程图符号
在绘制程序框图时，使用的符号说明如图4-1所示，拼图游戏系统处理方式的合理选择，其实就是一个处理过程的设计问题。选择处理方式实际上就是根据系统的任务、目标和环境条件，合理地选择信息活动的形态及具体方法。
程序流程图又称为方框图。表示方法简明直观，是用来描述程序执行的逻辑过程的。它把程序的基本步骤归纳为:处理、判断、输入/输出、开始和结束等几个基本功能，并用不同的记号加以表示，从而描述程序的执行过程。
系统流程图表达的是系统各部件的流动情况，而不是表示对信息进行加工处理的控制过程。
系统流程图的作用表现在以下几个方面:
1，制作系统流程图的过程是系统分析员全面了解系统业务处理概况的过程，它是系统分析员做进一步分析的依据。
2，系统流程图是系统分析员、管理员、业务操作员相互交流的工具。
3，系统分析员可直接在系统流程图上画出可以有计算机处理的部分。
4，可利用系统流程图来分析业务流程的合理性。
11
首先我在进行软件代码的编写设计之前对于软件的整体流程有一个大致的思路，如图4-2，即先将图片进行打散，然后即可进行拼图的过程，然后可对于拼图成功进行判断。
图4-2拼图游戏流程图
4.4功能模块设计
关于该拼图游戏的功能木模块设计，从逻辑上分析，该拼图游戏主要分成2块，也就是主要的两个窗体，分别为游戏界面部分和游戏部分，下面对该款拼图游戏进行功能设计分析。
12
游戏功能分为图片打散流程以及拼图流程，如图4-3和图4-4。
图4-3 拼图游戏随机打散图片流程
图4-4 拼图游戏拼图流程
13
首先，我需要对软件系统进行概要设计，即系统设计。概要设计需要对软件系统的设计进行考虑，包括系统的基本处理流程、系统的组织结构、模块划分、功能分配、接口设计、运行设计、数据结构设计和出错处理设计等，为软件的详细设计提供基础。
在概要设计的基础上，我需要进行软件系统的详细设计。在详细设计中，描述实 现具体模块所涉及到的主要算法、数据结构、类的层次结构及调用关系，需要说明软件系统各个层次中的每一个程序(每个模块或子程序)的设计考虑，以便进行编码和测试。应当保证软件的需求完全分配给整个软件。详细设计应当足够详细，能够根据详细设计
报告
软件系统测试报告下载sgs报告如何下载关于路面塌陷情况报告535n,sgs报告怎么下载竣工报告下载
进行编码。
在软件编码阶段，根据概要设计中对数据结构、算法分析和模块实现等方面的设计要求，开始具体的编写程序工作，分别实现各模块的功能，从而实现对目标系统的功能、性能、接口、界面等方面的要求。在
规范
编程规范下载gsp规范下载钢格栅规范下载警徽规范下载建设厅规范下载
化的研发流程中，编码工作在整个项目流程里最多不会超过1/2，通常在1/3的时间，所谓磨刀不误砍柴功，设计过程完成的好，编码效率就会极大提高，编码时不同模块之间的进度协调和协作是最需要小心的，也许一个小模块的问题就可能影响了整体进度，让很多程序员因此被迫停下工作等待，这种问题在很多研发过程中都出现过。
14
5 详细设计
5.1关键算法的设计与实现
对于一个拼图游戏的核心来说，主要的模块就是图片的随机打散模块和拼图模块。我将屏幕窗口分成9块，如图5-1所示。
图5-1 拼图区窗口
关于八数码问题，是该程序设计的一个难点，也是首要突破的一的难点，搞清楚八数码函数的运算逻辑是该程序设计的关键。
八数码问题(九宫问题)在一个3*3的九宫中有1-8这8个数及一个空格随机的摆放在其中的格子里。现在要求实现这个问题:将打乱的九宫格调整为与图片吻合的形式。调整的规则是:每次只能将与空格(上、下、或左、右)相邻的一个数字平移到空格中。
具体分析，九宫问题中，程序产生的随机排列转换成目标共有两种可能，而且这两种不可能同时成立，也就是奇数排列和偶数排列。我们可以把一个随机排列的数组从左到右从上到下用一个一维数组表示，我们就可以表示成,8，7，1，5，2，6，3，4，0,其中0代表空格。
状态为:
8 7 1
5 2 6
3 4 0
在这个数组中我们首先计算它能够重排列出来的结果，公式是:
?(,(,)),,，其中,(,)
就是一个数他前面比这个数小的数的个数，,为奇数和偶数各有一种解法。那么上面的数组我们就可以解出它的结果。
,(8),0;(数字8前没有比其小的数字)
,(7),0;
,(1),0;
,(5),1;(数字5前有一个比其小的数字“1”)
,(2),1;
,(6),3;
15
,(3),2;
,(4),3;
,,0，0，0，1，1，3，2，3,10
Y为偶数，所以进行偶数排列。
八数码问题是该游戏软件的设计重点，理解八数码函数是程序设计的关键。八数码问题用于拼图游戏中图片的拆分方法。也就是说，当运用到八数码问题后，按照八数码函数进行运算，才能保证图片拆分后，经过用户的拼凑，最终可以完成整个拼图游戏，而不会无解。
5.1.1图片随机分割问题
我们将图像也分成和屏幕窗口一样的9块，如图5-2所示。
图5-2 图像分割
在Qt中，视口是物理坐标系下指定的任意矩形，窗口指的是同一矩形，只不过是逻辑坐标系下的。我们先将视口设置成屏幕上的一块，然后窗口设置成一块大小和一块图像的大小一样的矩形，我们将一块图像绘制到窗口中，经过窗口-视口变换后就绘制到了视口所对应的屏幕上。
为了实现图像的随机打散，使用一个全局的映射数组map[3][3],map数组中存放的数字只能是0~8之间的数(包括0和8)。map[0][0]对应屏幕的0块，map[0][1]对应屏幕的1块，依次类推，map[3][3]对应屏幕的8块。如果map[0][0]里面存放的数是8，那么我们就将图像的第8块绘制到屏幕的第0块。如果map数组中的数字是随机打乱的，那么我们通过这个映射数组将图像绘制到屏幕上后，屏幕上将会是打乱的图像。
为了方便代码的重用，我们将map数组的随机打乱编写到一个函数random()中，这样游戏再玩一次的时候就可以直接再调用一次这个函数重新打散一次映射数组就可以了。
map数组在初始化的时候，我们给map[0][0]~map[3][3]依次放进去0~8，然后再调用一次random()函数后将图像绘制到屏幕上去生成最初的打乱的图像。
16
random()函数的算法是这样的，首先产生两个随机数，然后再将这两个随机数对9
求余的到两个9以内(即0~8且包括0和8)的随机数randData1和randData2，然后对
map[randData1/3][randData1%3]和map[randData2/3][randData2%3]进行交换。通过循环
将这样的交换多进行几轮，然后就得到了一个随机打散的映射数组map。 代码:
算法1
void PintuWindow::random()
{
int temp = -1;
int randData1 = -1;
int randData2 = -1;
srand(time(NULL));
for (int i = 0; i < 9; ++i)
{
randData1 = rand() % 9;
randData2 = rand() % 9;
temp = map[randData1/3][randData1%3];
map[randData1/3][randData1%3] = map[randData2/3][randData2%3];
map[randData2/3][randData2%3] = temp;
}
update();
}
算法2
void PintuWindow::random()
{
int temp = -1;
int randData = -1;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
{
randData = rand() % 9;
temp = map[i][j];
map[i][j] = map[randData/3][randData%3];
map[randData/3][randData%3] = temp;
}
,
打散4×4
void PintuWindow::random()
{
int temp = -1;
17
int randData = -1;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
{
randData = rand() % 9;
temp = map[i][j];
map[i][j] = map[randData/3][randData%3];
map[randData/3][randData%3] = temp;
}
update();
}
打散5×5
void PintuWindow2::random()
{
int temp = -1;
int randData = -1;
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5; ++j)
{
randData = rand() % 25;
temp = map[i][j];
map[i][j] = map[randData/5][randData%5];
map[randData/5][randData%5] = temp;
}
update();
}
绘图区代码:
void PintuWindow::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
painter.setPen(QPen(Qt::yellow,2));
painter.drawPixmap(this->rect(),QPixmap(":/images/gamebackground.jpg"));
// 整体框架
painter.drawRect(10,10,980,480);
painter.drawRect(15,15,970,470);
painter.drawLine(498,15,498,485);
painter.drawLine(502,15,502,485);
// 绘图区和原图区的绘制
painter.setPen(QPen(Qt::white,2));
18
painter.drawRect(20,20,473,460);
painter.drawRect(507,20,473,460);
// 窗口间距
int spaceX = 157;
int spaceY = 153;
// 加载图像
/*
QString str = ":/images/myImage";
int num = qrand()%3+1;
str +=QString::number(num);
str +=".jpg";
*/
QImage image(strImg);
//高、宽
int imageW = image.width();
int imageH = image.height();
//窗口间距
int spaceW = imageW / 3;
int spaceH = imageH / 3;
//原图视窗体
painter.setViewport(507,20,473,460);
painter.setWindow(0,0,imageW,imageH);
//对比图描绘
painter.drawImage(0,0,image);
//拼图区图像
painter.setWindow(0,0,spaceW,spaceH);
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
{
painter.setViewport(20 + i * spaceX + 1, 20 + j * spaceY + 1,
spaceX, spaceY);
painter.drawImage(0, 0, image, (map[i][j]/3) * spaceW,
(map[i][j]%3) * spaceH, spaceW, spaceH);
}
// 描绘网格线
painter.setViewport(20,20,473,460);
painter.setWindow(0,0,473,460);
painter.setPen(QPen(Qt::white,1));
painter.drawLine(spaceX,0,spaceX,460);
painter.drawLine(2*spaceX,0,2*spaceX,460);
painter.drawLine(0,spaceY,473,spaceY);
19
painter.drawLine(0,2*spaceY,473,2*spaceY);
// 选中的图像
if (selected.x != -1 && selected.y != -1)
{
painter.setViewport(20+selected.x * spaceX, 20+selected.y * spaceY,
spaceX, spaceY);
painter.setWindow(0, 0, spaceX, spaceY);
//凸显选中图像
painter.setPen(QPen(Qt::yellow,3));
painter.drawRect(0, 0, spaceX, spaceY);
}
}
对于拼图区中坐标的计算代码:
// 157*3+20=491 153*3+20=479
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
{
painter.setViewport(20 + i * spaceX + 1, 20 + j * spaceY + 1,
spaceX, spaceY);
painter.drawImage(0, 0, image, (map[i][j]/3) * spaceW,
(map[i][j]%3) * spaceH,
spaceW, spaceH);
}
// 117*4+20=491 114*4+20=479
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
{
painter.setViewport(20 + i * spaceX + 1, 20 + j * spaceY + 1,
spaceX, spaceY);
painter.drawImage(0, 0, image, (map[i][j]/4) * spaceW,
(map[i][j]%4) * spaceH,
spaceW, spaceH);
}
// 94*5+20=491 91*5+20=479
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5; ++j)
{
painter.setViewport(20 + i * spaceX + 1, 20 + j * spaceY + 1,
spaceX, spaceY);
painter.drawImage(0, 0, image, (map[i][j]/5) * spaceW,
(map[i][j]%5) * spaceH,
20
spaceW, spaceH);
}
5.1.2判断图片是否可以交换
首先获得鼠标点击的位置，判断鼠标点击的位置是否在拼图区，如果不在拼图区，将描述选中块的一个数据结构selected置成没有选中任何块，然后刷新就完了;如果在拼图区，那么接下来就进行下面的程序。
计算鼠标选中那一块，通过selected数据结构判断之前是否已经有选中块了，如果之前没有选中块，那么置selected数据结构中选中块为现在选中的块，然后刷新;如果之前有选中的块，那么就判断之前选中的块和现在选中的块是否是横纵相邻的，如果不是横纵相邻的，那么就重置selected数据结构中选中块为现在选中的块，然后刷新;如果之前选中的块和现在选中的块是横纵相邻的，那么就交换两个选中的块，然后刷新。
代码:
void PintuWindow::mousePressEvent(QMouseEvent *event)
{
int x = event->pos().x();
int y = event->pos().y();
//进行坐标范围的判定
if(20 < x && x < 491 && 20 < y && y < 479) // 157*3+20=491
153*3+20=479
{
int indX = (x - 20) / 157;
int indY = (y - 20) / 153;
if(-1 < selected.x && selected.x < 3 && -1 < selected.y && selected.y <
3)
{
if ((indX == selected.x &&
-2 < indY - selected.y &&
indY - selected.y < 2) ||
(-2 < indX - selected.x &&
indX - selected.x < 2 &&
indY == selected.y))
{
// 可以交换就交换
int temp = map[indX][indY];
map[indX][indY] = map[selected.x][selected.y];
map[selected.x][selected.y] = temp;
selected.x = -1;
selected.y = -1;
21
}else{
selected.x = indX;
selected.y = indY;
}
}else{
selected.x = indX;
selected.y = indY;
}
}else{
selected.x = -1;
selected.y = -1;
}
update();
// 判断是否成功，成功的话就弹出提示成功了
int i = 0;
for (; i < 9; ++i)
if (map[i/3][i%3] == i);
else break;
if(i == 9)
{
emit success();
}
}
如果空白label的x坐标与传入的labell的x坐标相等，即说明要移动的图片在空白label的上放或者下方，空白label的y坐标减去传入labell的y坐标的绝对值等于空白label的的高度时返回true; 即可以移动;
如果空白label的y坐标与传入的labell的y坐标相等，即说明要移动的图片咋空白label的左侧或者右侧，空白label的x坐标减去传入labell的x坐标的绝对值等于空白label的的宽度时返回true; 即可以移动。
我将判断游戏是否成功也放在了这个函数中，但是在模块的划分中，这是单独的一块，只是实现时为了实现方便将两个模块结合到了单独的一个函数中。 5.1.3更改图片
进行对文件名称strImg进行全局变量的定义QString并对其赋初值
QString strImg = “:/images/myImage1.jpg”
void PintuWindow2::changeimage()
{
//cout << "123" << endl;
//使用字符串的连接
22
strImg2 = ":/images/myImage";
//产生随机数
int num = qrand()%4+1;
strImg2 +=QString::number(num);
strImg2 +=".jpg";
//QImage image(str);
repaint();
}
5.2模块命名规则
整个游戏我用一个类PintuWindow进行描述。这个类继承自QMainWindow，其头文件为pintuwindow.h，实现文件为pintuwindow.cpp。
在PintuWindow类中，自定义了一个信号void success()，然后两个私有槽void random()和void succeed()。在Pintu类的构造函数中，我将success()信号连接到槽succeed()以便在发射success()信号的时候可以自动执行secceed()槽。那么在每次两个图块交换后我就判断游戏是否成功，如果成功，就会发射success()信号。random()实现图块的随机打算，secceed()实现游戏成功的处理。
重新实现了两个虚函数void paintEvent(QPaintEvent *event)和void mousePressEvent(QMouseEvent *event)以实现绘图和鼠标操作。然后是一个描述映射的数组int map[3][3]，一个描述选中的情况的结构体struct pair selected和一个指向成功时弹出的那个对话框的指针SuccessDialog *successDialog等私有成员。
游戏窗口的代码:
#include
#include"successdialog.h"
#include
#include
#include
struct pair
{
int x;
int y;
};
class PintuWindow : public QWidget {
Q_OBJECT
public:
PintuWindow();
signals:
void success();
23
void showMainWidget();
private slots:
//定义槽函数
void random();
void succeed();
void closeWidget();
void changeimage();
private:
//定义绘图事件，鼠标事件
//定义按钮
void paintEvent(QPaintEvent *event);
void mousePressEvent(QMouseEvent *event);
//QPixmap *image;
QPushButton *replaygame;
QPushButton *backmenu;
QPushButton *change;
QPushButton *overgame;
int map[3][3];
struct pair selected;
SuccessDialog *successDialog; };
SuccessDialog类是在游戏成功时显示的一个对话框，继承自QDialog，其头文件是sucessdialog.h，实现文件时successdialog.cpp。在这个类中自定义了两个信号void replay()
和void exit()。
重新实现了void paintEvent(QPaintEvent *event)用以在对话框中插入一张图片。然后就是一个QLabel *succ指向显示祝贺语的QLable，一个指向QPushButton重玩按钮的QPushButton *buttonReplay和一个指向QPushButton推出按钮的QPushButton *buttonExit。
当用户单击重玩按钮时就会先发射replay()信号，然后执行关闭这个对话框的槽。Replay信号在void PintuWindow::succeed()函数中是连接到了类PintuWindow的random()槽。所以当我们单击rePlay按钮的时候会关闭对话框，重新随机打散图像，重新进行拼图游戏。
当用户单击exit按钮时就是发射exit信号，然后执行关闭这个对话框的槽。exit()信号在void PintuWindow::succeed()函数中是连接到了类PintuWindow的close()槽，类PintuWindow的close()槽会关闭整个拼图游戏程序的窗口，然后结束拼图游戏。
Successdialog文件代码:
#ifndef SUCCESSDIALOG_H
#define SUCCESSDIALOG_H
#include
#include
#include
24
#include
class SuccessDialog : public QDialog {
Q_OBJECT
public:
//定义成功窗口
SuccessDialog(QWidget *parent = 0); signals:
//定义重玩和退出信号
void replay();
void exit();
private:
//定义私有成员
//绘图事件，按钮
void paintEvent(QPaintEvent *event);
QLabel *succ;
QPushButton *buttonReplay;
QPushButton *buttonExit;
};
#endif
模块完成代码:
Successdialog.cpp\
#include
#include"successdialog.h"
#include
SuccessDialog::SuccessDialog(QWidget *parent) : QDialog(parent)
{
//succ = new QLabel(QObject::trUtf8("Congratulations,\nPintu Succeed ^_^(%1)"));
succ = new QLabel(this);
setWindowTitle(tr("Pintu"));
//成功窗口的绘制
buttonReplay = new QPushButton(tr("Replay"));
buttonExit = new QPushButton(tr("Exit"));
QHBoxLayout *topLayout = new QHBoxLayout;
topLayout->addStretch();
topLayout->addWidget(succ);
topLayout->addStretch();
QHBoxLayout *bottomLayout = new QHBoxLayout;
bottomLayout->addWidget(buttonReplay);
25
bottomLayout->addWidget(buttonExit);
QVBoxLayout *mainLayout = new QVBoxLayout();
mainLayout->addLayout(topLayout);
mainLayout->addLayout(bottomLayout);
setLayout(mainLayout);
//槽函数添加
connect(buttonReplay,SIGNAL(pressed()),this,SIGNAL(replay()));
connect(buttonReplay,SIGNAL(pressed()),this,SLOT(close()));
connect(buttonExit,SIGNAL(pressed()),this,SIGNAL(exit()));
connect(buttonExit,SIGNAL(pressed()),this,SLOT(close())); }
//绘图事件
void SuccessDialog::paintEvent(QPaintEvent *event) {
QPainter painter(this);
QImage image(":/images/backgroundsmall.jpg");
painter.setWindow(0,0,image.width(),image.height());
painter.drawImage(0,0,image);
}
5.3 QSS文件
设计Qt程序Ui的时候，可以像WEB端使用CSS一样，使用QSS，使页面美化
跟代码层分开，利于维护。
以简单按钮为例的代码:
QPushButton{
background-image: url(:/images/easyButton2.png);
border-style:outset;
border-radius:10px;
}
QPushButton:hover{
background-image: url(:/images/easyButton1.png);
border-style:outset;
border-radius:10px;
}
QPushButton:pressed{
background-image: url(:/images/easyButton3.png);
26
border-style:outset;
border-radius:10px;
}
5.4 用户界面快照设计概述
界面非常简单，一个窗口分成了两个区域，一个拼图区，一个原图区。原图区显示原图，用以作拼图时的参照，拼图区实现拼图，界面快照如图5-3、图5-4和图5-5。
图5-3 游戏开始界面快照
游戏开始时点击游戏界面中的简单、一般、困难按钮时会进入到正式的游戏界面，即3宫、4宫、5宫的游戏界面，玩家可以根据自己的兴趣及实力选择不同的难度进行游戏。
27
图5-4 简单游戏界面快照
进入到正式游戏界面中，开始进行拼图。选择其中的不再适当位置的图片与其横纵相邻的一张图片进行交换，一一进行，知道将所有的图片都交换到自己所在的位置，完成拼图，弹出成功对话框，之后玩家可以进行重玩，重选图片，其他难度或直接退出游戏。
图5-5 完成界面快照
28
6 软件测试
对于一个开发中的软件来说，系统测试是衡量软件产品质量的重要保证活动之一。因为在系统开发以及修改的过程中，在各个阶段都有可能存在错误和缺陷。通过测试可以发现系统设计中存在的种种问题，并可以及时改正，避免在系统投入使用时才发现不必要的错误，从而导致不必要的损失，尤其对于大多数将要投入市场的软件产品而言，及时挽救错误能够保证研发者和用户群体的利益。测试是质量保证一个砝码，它提供对系统规格说明、设计和编码的最终评审，是发现系统缺陷和错误的有力手段。
6.1测试的目的及相关问题
软件测试分为几个部分:单元测试集中检查软件设计的最小单元——模块，包括程序测试，即发现程序中的代码错误，然后逐一解决;组装测试相当于联调，主要是考察模块间的接口和各模块之间的联系。这是一个持续的过程，可以在将组件加入某一项之前逐个的加以测试，也可以把项目连编成应用程序之后再进行测试。确认测试主要检查软件功能与用户的需求是否一致。在一般的情况下，这些步骤都被顺序地实现。
在测试和调试应用程序时，应注意以下问题:
1(程序设计者不应测试自己设计的程序;
2(测试用例的设计不仅要有合理的输入数据，还要有不合理的输出数据;
3(除了检查程序是否做完了它应做的事之外，还要检查它是否做完了它不应做的事。
在测试和调试应用程序后，拼图游戏系统应达到以下要求:
1(能较好的完成系统应具备的基本功能;
2(运行不会导致崩溃或产生错误信息;
3(在一般情况下操作正常;
4(在一定范围内，操作合理，或能提供适当的错误信息。
程序调试和组件测试我们在设计和编码的过程中通过编译程序编译、软件错误信息的提供，我们可以逐步修正错误，程序能够得到一步的完善。
每当测试一个程序时，人们总希望为程序增加一些价值。利用测试来增加程序的价值，是指通过测试，找出并修改尽可能多的程序缺陷，从而提高程序的可靠性或质量。因此，不要只是为了证明程序能够正确运行而去测试程序。相反，应该一开始就假设程序中隐藏着错误(这种假设几乎对所有的程序都成立)，然后测试程序，发现尽可能多的错误。事实上，如果把测试目标定位于要证明程序中没有缺陷，那么就会在潜意识中倾向于实现这个目标。也就是说，测试人员会倾向于挑选那些使程序失效的可能性较小的测试数据。另一方面，如果把测试目标定位于要证明程序中存在缺陷，那么就会选择一些容易发现程序缺陷的测试数据。而后一种态度会比前者给程序增加更多的价值。
29
6.2测试方法
测试，通常有两种方式:单元测试和组装测试。对本系统而言，选择单元测试的测试方法。单元测试中设计白盒测试以及黑盒测试。黑盒测试即针对程序所有功能设计的测试方法，而白盒测试针对程序的逻辑结构设计测试用例，用逻辑覆盖率来衡量测试的完整性。黑盒测试的缺点在于其难于衡量测试的完整性，而白盒测试恰恰具有易于衡量测试完整性的优点，两者之间具有极好的互补性。所以在对一个软件产品进行测试时，为了谨慎全面的测试出软件的质量，通常使用白盒测试法，也就是根据程序的内部处理逻辑来设计测试用例。白盒测试法主要的方法有:语句覆盖，条件覆盖，判定覆盖，判定条件覆盖，条件组合覆盖，路径覆盖，本系统根据白盒测试法来设计测试用例。
白盒技术
白盒测试是结构测试，所以被测对象基本上是源程序，以程序的内部逻辑为基础设计测试用例。
1逻辑覆盖
程序内部的逻辑覆盖程度，当程序中有循环时，覆盖每条路径是不可能的，要设计使覆盖程度较高的或覆盖最有代表性的路径的测试用例。下面根据图7-1所示的程序，分别讨论几种常用的覆盖技术。
(1)语句覆盖。
为了提高发现错误的可能性，在测试时应该执行到程序中的每一个语句。语句覆盖是指设计足够的测试用例，使被测试程序中每个语句至少执行一次。
(2)判定覆盖。
判定覆盖指设计足够的测试用例，使得被测程序中每个判定表达式至少获得一次“真”值和“假”值，从而使程序的每一个分支至少都通过一次，因此判定覆盖也称分支覆盖。
(3)条件覆盖。
条件覆盖是指设计足够的测试用例，使得判定表达式中每个条件的各种可能的值至少出现一次。
(4)判定条件覆盖。
该覆盖
标准
excel标准偏差excel标准偏差函数exl标准差函数国标检验抽样标准表免费下载红头文件格式标准下载
指设计足够的测试用例，使得判定表达式的每个条件的所有可能取值至少出现一次，并使每个判定表达式所有可能的结果也至少出现一次。
(5)条件组合覆盖。
条件组合覆盖是比较强的覆盖标准，它是指设计足够的测试用例，使得每个判定表达式中条件的各种可能的值的组合都至少出现一次。
(6)路径覆盖。
路径覆盖是指设计足够的测试用例，覆盖被测程序中所有可能的路径。
在实际的逻辑覆盖测试中，一般以条件组合覆盖为主设计测试用例，然后再补充部分用例，以达到路径覆盖测试标准。
2循环覆盖
3基本路径测试
黑盒技术
30
1等价类划分
(1)划分等价类。
在输入条件规定了取值范围或值的个数的情况下，则可以确立一个有效等价类和两个无效等价类。
在输入条件规定了输入值的集合或者规定了“必须如何”的条件的情况下，可确立一个有效等价类和一个无效等价类。
在输入条件是一个布尔量的情况下，可确定一个有效等价类和一个无效等价类。
在规定了输入数据的一组值(假定n个)，并且程序要对每一个输入值分别处理的情况下，可确立n个有效等价类和一个无效等价类。
在规定了输入数据必须遵守的规则的情况下，可确立一个有效等价类(符合规则)和若干个无效等价类(从不同角度违反规则)。
在确知已划分的等价类中各元素在程序处理中的方式不同的情况下，则应再将该等价类进一步的划分为更小的等价类。
(2)确定测试用例。
为每一个等价类编号。
设计一个测试用例，使其尽可能多地覆盖尚未被覆盖过的合理等价类。重复这步，直到所有合理等价类被测试用例覆盖。
设计一个测试用例，使其只覆盖一个不合理等价类。
3边界值分析
使用边界值分析方法设计测试用例时一般与等价类划分结合起来。但它不是从一个等价类中任选一个例子作为代表，而是将测试边界情况作为重点目标，选取正好等于、刚刚大于或刚刚小于边界值的测试数据。
如果输入条件规定了值的范围，可以选择正好等于边界值的数据作为合理的测试用例，同时还要选择刚好越过边界值的数据作为不合理的测试用例。如输入值的范围是[1，100]，可取0，1，100，101等值作为测试数据。
如果输入条件指出了输入数据的个数，则按最大个数、最小个数、比最小个数少1、比最大个数多1等情况分别设计测试用例。如，一个输入文件可包括1--255个记录，则分别设计有1个记录、255个记录，以及0个记录的输入文件的测试用例。
对每个输出条件分别按照以上原则?或?确定输出值的边界情况。如，一个学生成绩管理系统规定，只能查询95--98级大学生的各科成绩，可以设计测试用例，使得查询范围内的某一届或四届学生的学生成绩，还需设计查询94级、99级学生成绩的测试用例(不合理输出等价类)。
由于输出值的边界不与输入值的边界相对应，所以要检查输出值的边界不一定可能，要产生超出输出值之外的结果也不一定能做到，但必要时还需试一试。
如果程序的规格说明给出的输入或输出域是个有序集合(如顺序文件、线形表、链表等)，则应选取集合的第一个元素和最后一个元素作为测试用例。
3.错误推测
在测试程序时，人们可能根据经验或直觉推测程序中可能存在的各种错误，从而有针对性地编写检查这些错误的测试用例，这就是错误推测法。
4.因果图
等价类划分和边界值方法分析方法都只是孤立地考虑各个输入数据的测试功能，而
31
没有考虑多个输入数据的组合引起的错误。
5.综合策略
每种方法都能设计出一组有用例子，用这组例子容易发现某种类型的错误，但可能不易发现另一类型的错误。因此在实际测试中，联合使用各种测试方法，形成综合策略，通常先用黑盒法设计基本的测试用例，再用白盒法补充一些必要的测试用例。 6.3部分测试用例
测试用例是为某个特殊目标而编制的一组测试输入、执行条件以及预期结果，以便测试某个程序路径或核实是否满足某个特定需求。
测试用例是将软件测试的行为活动做一个科学化的组织归纳，目的是能够将软件测试的行为转化成可管理的模式;同时测试用例也是将测试具体量化的方法之一，不同类别的软件，测试用例是不同的。不同于诸如系统、工具、控制、游戏软件，管理软件的用户需求更加不同的趋势。
6.3.1拼图测试
表6-1 拼图测试
测试用例 1
描述 测试游戏是否能拼图，能否拼图成功
测试方法 点击鼠标左右键进行游戏，直至拼图成功
期望结果 成功产生相应的拼图成功效果
测试结果(正确或错误) 正确
拼图测试的测试用例表如表6-1所示，表中体现出该用例是针对拼图游戏是否能和正常拼图而进行测试的。测试方法即运行程序即可，若能正常拼图，达到预期目标，即点击鼠标左右键进行游戏，能够拼图，并直至拼图成功，那么说明拼图过程正常，测试完成了预期目标，达到测试目的。
6.3.2游戏难度测试
表6-2 游戏难度测试
测试用例 2
描述 测试游戏难度情况
测试方法 点击游戏难度选择相应的难度，每种都能拼图
成功
32
期望结果 初级，中级，高级均可拼图成功
测试结果(正确或错误) 正确
游戏难度测试的测试用例表如表6-2所示，表中体现出该用例是针对拼图游戏能否正常进行难度选择，并完成个难度的拼图游戏而进行测试的。测试方法即运行程序即可，若能选择三中难度并且可以正常拼图，直至拼图成功，即点击游戏难度选择相应的难度，每种都能拼图成功，那么说明拼图过程难度选择功能正常，测试完成了预期目标，达到测试目的。
6.3.3拼图游戏窗体外观测试
表6-3 游戏外观测试
测试用例 3
描述 测试拼图游戏窗体外观
测试方法 点击系统提供的相应外观选项
期望结果 出来的效果均是选择的相应选项相符
测试结果(正确或错误) 正确
游戏窗体外观测试的测试用例表如表6-3所示，表中体现出该用例是针对拼图游戏能否正常进行窗体外观选择的。测试方法即运行程序即可，从难度选择按钮到达不同难度游戏界面项，若能选择三种外观样式并且可以正常显示外观，即点击系统提供的相应的外观选项，那么说明拼图过程中外观更换功能正常，测试完成了预期目标，达到测试目的。
6.4测试分析和总结
测试的内容应该包括合法性测试、非法测试以及边缘测试，所以除了以上测试用例之外，还对该软件系统进行了边缘测试以及非法测试。通过测试，同样可以证明软件系统能够在非法信息的录入下报错，并且能够对边缘信息的录入做出反应。
这个软件相当于一个拼图游戏的内核，可以围绕着这个内核进行许多的扩展，做成符合不同要求的拼图游戏。例如，在这个游戏中加进一个定时器，将拼图的时间设置为一个与重玩次数相关的算法生成的时间或者设置成有用户自定义的形式。当定时器的时间用完的时候如果用户还没有完成拼图，那么就游戏失败。这个扩展时很容易实现的，而且游戏的图片随机打散算法和拼图算法以及拼图区和原图区的绘图等核心部分也不会改变。
还例如，还可以扩展成让用户自己选择一副自己喜欢的图片进行拼图。那么这个时候需要一个动态加载用户图片的模块。另外，就是需要将QImage对象(QImage对象是表示拼图游戏使用的图片的一个类)从paintEvent(QPaintEvent *event)函数的局部数据区
33
移动到PintuWindow的全局数据区成为类PintuWindow的一个私有成员。这个动态加载图片的模块就用以更新QImage对象中使用的图片。这种情况下，游戏的图片随机打散算法和拼图算法都不会改变。由于用户选择的图片的像素不同，拼图区和原图区的绘图只需要稍稍修改一个计算就可以了。
所以综上所述，该软件一系列的测试能够证明系统数据处理具有安全性及稳定性，在数据出错情况下能够给出正确提示，当系统出现异常时，能够正确捕获并进行相应的处理或给予提示。
34
结 论
相信在大学期间，很多同学都参与过或者是编写过拼图游戏软件的程序，那么这次作为毕业设计，要想更加出色的完成这个课题，并且具有独特之处，就是我编写程序之前首先要考虑到的问题。但是，对于拼图游戏而言，寻找游戏的创新突破口也有一定的难度。从游戏的功能方面入手寻找创新突破口，我决定在传统的拼图游戏的功能基础之上，增加一个自定义图片功能，让用户可以选择自己电脑里的图片，进行拼图游戏。其次，功能设计方面，出色地完成好难度区分也是一个难题。当然在完成该课题的过程中，都一一解决了这些问题。其他编程过程中的难点还包括如何拆分图片、如何实现背景音乐的播放等。除了对于游戏功能方面的创新，还在制作拼图游戏的选材方面寻求突破，也就是对游戏界面的设计多花心思，多下功夫。尽力去满足更多用户群体的需求，争取满足不同用户的喜好。
在做毕业设计以前，我对C游戏开发只是停留在理论知识的水平上，是“纸上谈兵”，缺乏实际的软件开发经验。这次通过做毕业设计，我完成了拼图游戏的软件开发任务。在整个开发过程中也遇到了很多问题，如载入图片的处理，难度选择，外观更换，图片分割，图片移动等。对其设计体会总结如下:
1. 为了熟悉拼图游戏的相关运作和功能设计，我从网上下载了各种拼图游戏，了解并研究各自的功能设计，总结出哪些是好的功能设计，哪些是不必要的设计。对尝试过的拼图游戏进行总结，将各自的优点融入我的设计之中。
2. 完成了从“小而全”，到“全而精”的转变。设计过程中,经常会遇到困难,我学会通过反复思考和测试，找出自己的错误并加以改正，再进行下一个步骤。这个程序就是在这样反复的发现错误、改正错误中完成的。完成游戏雏形之后，再进行逐步的完善。
3. 这是一个不断学习新鲜事物的过程，从设计初的不懂到最后能够顺利完成，我体会到在实践中学习的重要性，这对于将来我走上工作岗位具有重要意义，相信这也是布置此项毕业设计的初衷。
开发过程中我学到了一些经验:系统分析的好坏将决定着的系统开发成功与否，一份好分析设计将是成功开发主要因素。我们在着手开发之前不要急于编程，先应有较长的时间去把分析做好，做好数据库设计工作，写出相关的开发文档等。然后再开始编写程序代码，这样做到每写一步代码心底有数,有条不絮。
良好的文档是正规研发流程中非常重要的环节， 作为代码程序员， 30 ,的工作时 间写技术文档是很正常的， 缺乏文档， 一个软件系统就缺乏生命力， 在未来的查 错， 升级以及模块的复用时就都会遇到极大的麻烦。 这次的这个小小的项目， 就 因为文档上的一点点理解错误让我们花了很大的工夫去改代码， 改页面。 很庆幸 的是，这是一个小项目，要是大项目，这种问题可能就会导致大量的代码修改， 可见文档在一个项目中起者巨大的做用。 此外， 良好的代码编写习惯， 不但有助于代码的移植和纠错， 也有助于不同技术 人员之间的协作。 作为一个程序员， 对需求的理解能力也是很重要的， 只有真正 理解了一个模块的作用， 才会写出高效率的代码， 才能使整个软件项目作出来更 加优秀， 具备更好的安全性和稳定性， 我在写代码的过程中就遇到了需求理解上 的问题，使得写出来的代码功能不全，幸好不是给客户发现在，要不，这个软件 的商业价值可能就会打折扣了。 单元测试对于一个程序员来说是不可
35
不做的一项 工作， 不做好测试就会给后期的集成工作带来麻烦， 往往为了一个小问题会让我 们查找好多模块，给后期工作带来很大麻烦。
此外，我还觉得，我个人在这次设计中走了很多弯路。主要是因为平时很少接触软件开发工作，尽管相关理论考试已经通过了，但在应用方面缺乏经验，如果及时得到老师或专家的指点，象这样的系统开发起来应该还比较容易。
经过三个月的不断努力,毕业设计内容已经完成了。回顾这个设计过程,我学到了许多书本上没有学到的知识。通过这次自己制作软件,丰富了自己的实践技能,扩展了相关知识,使我受益匪浅，也感受到了软件开发的不易。由于我对软件开发还只是一个新手，了解的不多，这其中一定还有很多的不足，也许有些模块未能做得尽如人意。但可以肯定的是，通过此次毕业设计，我确实收获了许多意想不到的东西，不光是编程语言，也包括对于软件设计的重新认识以及对于软件开发人员工作的理解。总的来说，我认为此次毕业设计还是比较成功的，这也是我大学四年来最具成就感的软件开发程序设计。
36
参考文献
[1] 杜晨.互联网上的拼图游戏[J].IT经理世界，2005，(11)
[2] 谭浩强.C程序设计(第3版)[M].清华大学出版社，2005
[3] 刘海燕，荆涛.Linux系统应用与开发教程[M].机械工业出版社，2010
[4] 严蔚敏，吴伟民.数据结构(C语言版)[M].清华大学出版社，2007
[5] 章英，叶颖泽.在“拼图”游戏中学习C语言[J].湖北教育学院院报,2007，(02)
[6] 刘天时，李皎，陈明晰.游戏算法分析在C语言教学中的应用[J].中国科学信息，2007，(04)
[7] 杜晨.互联网上的拼图游戏[J].IT经理世界，2005，(11)
[8] 龚立威.一种嵌入式游戏系统的研究与实现[D].华南理工大学，2010
[9] A.A.Puntambekar.Advanced Structures and Algorithms[M].Technical Publications,2008
[10] Stphen Prata.C Primer Plus,Fifth Edition[M].Sams Publishing,2005 [11] Andrew Andrew.C Traps and Pitfalls[MA].Addison-Wesley,1988
37
致 谢
论文都是闫宏印老师全面、具体指导下完成进行的，闫宏印老师渊博的学识、敏锐的思维、民主而严谨的作风使我受益非浅，并终生难忘。在整个软件设计完成过程中，在整体的思路设计，功能分析的设计方法和处理技巧以及功能实现的算法等方面得到了亢海波老师的大量指导和帮助。
感谢闫宏印老师、亢海波老师在毕业设计工作中给予的帮助。
感谢我的学友和朋友对我的关心和帮助。
38
外文原文
C
Main article: C variable types and declarations，C has a static weak typing type system
that shares some similarities with that of other ALGOL descendants such as Pascal. There are built-in types for integers of various sizes, both signed and unsigned, floating-point numbers, characters, and enumerated types (enum). C99 added a boolean datatype. There are also derived types including arrays, pointers, records (struct), and untagged unions (union).
C is often used in low-level systems programming where escapes from the type system may be necessary. The compiler attempts to ensure type correctnessof most expressions, but the programmer can override the checks in various ways, either by using a type cast to explicitly convert a value from one type to another, or by using pointers or unions to reinterpret the underlying bits of a data object in some other way.
Some find C's declaration syntax unintuitive, particularly for function pointers. (Ritchie's idea was to declare identifiers in contexts resembling their use: "declaration reflects use".)
C's usual arithmetic conversions allow for efficient code to be generated, but can sometimes produce unexpected results. For example, a comparison of signed and unsigned integers of equal width requires a conversion of the signed value to unsigned. This can generate unexpected results if the signed value is negative.
C supports the use of pointers, a type of reference that records the address or location of an object or function in memory. Pointers can be dereferenced to access data stored at the address pointed to, or to invoke a pointed-to function. Pointers can be manipulated using assignment or pointer arithmetic. The run-time representation of a pointer value is typically a raw memory address (perhaps augmented by an offset-within-word field), but since a pointer's type includes the type of the thing，pointed to, expressions including pointers can be
type-checked at compile time. Pointer arithmetic is automatically scaled by the size of the pointed-to data type. Pointers are used for many different purposes in C. Text strings are commonly manipulated using pointers into arrays of characters. Dynamic memory allocation
39
is performed using pointers. Many data types, such as trees, are commonly implemented as dynamically allocated struct objects linked together using pointers. Pointers to functions are useful for passing functions as arguments to higher-order functions (such as qsort or bsearch) or as callbacks to be invoked by event handlers.
A null pointer value explicitly points to no valid location. Dereferencing a null pointer value is undefined, often resulting in a segmentation fault. Null pointer values are useful for indicating special cases such as no "next" pointer in the final node of a linked list, or as an error indication from functions returning pointers. In appropriate contexts in source code, such as for assigning to a pointer variable, a null pointer constant can be written as 0, with or without explicit casting to a pointer type, or as the NULL macro defined by several standard headers. In conditional contexts, null pointer values evaluate to false, while all other pointer values evaluate to true.
Void pointers (void *) point to objects of unspecified type, and can therefore be used as "generic" data pointers. Since the size and type of the pointed-to object is not known, void pointers cannot be dereferenced, nor is pointer arithmetic on them allowed, although they can easily be (and in many contexts implicitly are) converted to and from any other object pointer type.
Careless use of pointers is potentially dangerous. Because they are typically unchecked, a pointer variable can be made to point to any arbitrary location, which can cause undesirable effects. Although properly used pointers point to safe places, they can be made to point to unsafe places by using invalid pointer arithmetic; the objects they point to may be deallocated and reused (dangling pointers); they may be used without having been initialized (wild pointers); or they may be directly assigned an unsafe value using a cast, union, or through another corrupt pointer. In general, C is permissive in allowing manipulation of and conversion between pointer types, although compilers typically provide options for various levels of checking. Some other programming languages address these problems by using more restrictive reference types.
40
Array types in C are traditionally of a fixed, static size specified at compile time. (The more recent C99 standard also allows a form of variable-length arrays.) However, it is also possible to allocate a block of memory (of arbitrary size) at run-time, using the standard library's malloc function, and treat it as an array. C's unification of arrays and pointers means that declared arrays and these dynamically allocated simulated arrays are virtually interchangeable.
Since arrays are always accessed (in effect) via pointers, array accesses are typically not checked against the underlying array size, although some compilers may provide bounds checking as an option.[31] Array bounds violations are therefore possible and rather common in carelessly written code, and can lead to various repercussions, including illegal memory accesses, corruption of data, buffer overruns, and run-time exceptions. If bounds checking is desired, it must be done manually.
C does not have a special provision for declaring multidimensional arrays, but rather relies on recursion within the type system to declare arrays of arrays, which effectively accomplishes the same thing. The index values of the resulting "multidimensional array" can be thought of as increasing in row-major order.
Multidimensional arrays are commonly used in numerical algorithms (mainly from applied linear algebra) to store matrices. The structure of the C array is well suited to this particular task. However, since arrays are passed merely as pointers, the bounds of the array must be known fixed values or else explicitly passed to any subroutine that requires them, and dynamically sized arrays of arrays cannot be accessed using double indexing. (A workaround for this is to allocate the array with an additional "row vector" of pointers to the columns.)
C99 introduced "variable-length arrays" which address some, but not all, of the issues with ordinary Array-pointer interchangeability。The subscript notation x[i] (where x
designates a pointer) is a syntactic sugar for *(x+i).[32] Taking advantage of the compiler's knowledge of the pointer type, the address that x + i points to is not the base address (pointed
41
to by x) incremented by i bytes, but rather is defined to be the base address incremented by i multiplied by the size of an element that x points to. Thus, x[i] designates the i+1th element of the array.
Furthermore, in most expression contexts (a notable exception is as operand of sizeof), the name of an array is automatically converted to a pointer to the array's first element. This implies that an array is never copied as a whole when named as an argument to a function, but rather only the address of its first element is passed. Therefore, although function calls in C use pass-by-value semantics, arrays are in effect passed by reference.
The size of an element can be determined by applying the operator sizeof to any dereferenced element of x, as in n = sizeof *x or n = sizeof x[0], and the number of elements in a declared array A can be determined as sizeof A / sizeof A[0]. The latter only applies to array names: variables declared with subscripts (int A[20]). Due to the semantics of C, it is not possible to determine the entire size of arrays through pointers to arrays or those created by dynamic allocation (malloc); code such as sizeof arr / sizeof arr[0] (where arr = A designates a pointer) will not work since the compiler assumes the size of the pointer itself is being requested.[33][34] Since array name arguments to sizeof are not converted to pointers, they do not exhibit such ambiguity. However, arrays created by dynamic allocation are initialized to pointers rather than true array variables, so they suffer from the same sizeof issues as array pointers.
Thus, despite this apparent equivalence between array and pointer variables, there is still a distinction to be made between them. Even though the name of an array is, in most expression contexts, converted into a pointer (to its first element), this pointer does not itself occupy any storage; the array name is not an l-value, and its address is a constant, unlike a pointer variable. Consequently, what an array "points to" cannot be changed, and it is impossible to assign a new address to an array name. Array contents may be copied, however, by using the memcpy function, or by accessing the individual elements.
Puzzles
42
Many puzzles are termed "fully interlocking". This means that adjacent pieces are connecting such that if you move one piece horizontally you move all, preserving the connection. Sometimes the connection is tight enough to pick up a solved part holding one piece.
Some fully interlocking puzzles have pieces all of a similar shape, with rounded tabs out on opposite ends, with corresponding blanks cut into the intervening sides to receive the tabs of adjacent pieces. Other fully interlocking puzzles may have tabs and blanks variously arranged on each piece, but they usually have four sides, and the numbers of tabs and blanks thus add up to four. The uniform-shaped fully interlocking puzzles, sometimes called "Japanese Style", are the most difficult, because the differences in shapes between pieces can be very subtle.[citation needed]
Some puzzles also have pieces with non-interlocking sides that are usually slightly curved in complex curves. These are actually the easiest puzzles to solve, since fewer other pieces are potential candidates for mating.
Most jigsaw puzzles are square, rectangular, or round, with edge pieces that have one side that is either straight or smoothly curved to create this shape, plus four corner pieces if the puzzle is square or rectangular. Some jigsaw puzzles have edge pieces that are cut just like all the rest of the interlocking pieces, with no smooth edge, to make them more challenging. Other puzzles are designed so the shape of the whole puzzle forms a figure, such as an animal. The edge pieces may vary more in these cases.
Requirements Phase The chances of a product being developed on time and within budget are somewhat slim unless the members of the software development team agree on what the software product will do. The first step in achieving this unanimity is to analyze the client’s current situation as precisely as possible. For example, it is inadequate to say, “ They need a computer-aided design system because they claim their manual design system, there is lousy. “ Unless the development team knows exactly what is wrong with the current manual system, there is a high probability that aspects of the new computerized
43
system will be equally “lousy. “ Similarly, if a personal computer manufacturer is
contemplating development of a new operating system, the first step is to evaluate the firm’s
current operating system and analyze carefully exactly why it is unsatisfactory. To take an extreme example, it is vital to know whether the problem exists only in the mind of the sales manager, who blames the operating system for poor sales, or whether users of the operating system are thoroughly disenchanted with its functionality and reliability. Only after a clear picture of the present situation has been gained can the team attempt to answer the critical question, What must the new product be able to do? The process of answering this question is carried out during the requirements phase.
A commonly held misconception is that , during the requirements phase, the developers must determine what software the client wants. On the contrary, the real objective of the requirements phase is to determine what software the client needs. The problem is that many clients do not know what they need. Furthermore, even a client who has a good idea of what is needed may have difficulty in accurately conveying these ideas to the developers, because most clients are less computer literate than the members of the development team.
To elicit the client’s needs, the members of the requirements team must be familiar with the application domain, that is, the general area in which the proposed software product is to be used. For example, it is not easy to ask meaningful questions of a banker or a nurse without first acquiring some familiarity with banking or nursing. Therefore, one of the initial tasks of each member of the requirements analysis team is to acquire familiarity with the application domain unless he or she already has experience in that general area. It is particularly important to use correct terminology when communicating with the client and potential users of the target software. After all, it is hard to be taken seriously by a person working in a specific domain unless the interviewer uses the nomenclature appropriate for that domain.
More important, use of an inappropriate word may lead to a misunderstanding, eventually resulting in a faulty product being delivered. The same problem can arise if the
44
members of the requirements team do not understand the subtleties of the terminology of the domain. One way to solve the problem with terminology is to build a glossary. The initial entries are inserted while the team learns the application domain. Then the glossary is updated whenever the members of the requirements team encounter new terminology. Not only does such a glossary reduce confusion between client and developers, it also is useful in lessening misunderstandings between members of the development team.
Once the requirements team have acquired familiarity with the domain, the next step is for them to start to determine the client’s needs, that is, requirements elicitation. Elicitation
technique as follows:
Interviews.
The members of the requirements team meet with members of the client organization until they are convinced that they have elicited all relevant information from the client and future users of the product. There are two basic types of interview, structured and unstructured. In a structured interview, specific, preplanned, close-ended questions are posed. In an unstructured interview, open-ended questions are asked, to encourage the person being interviewed to speak out. Some of these facts might not have come to light had the interview been more structured. At the same time, it is not a good idea if the interview is too unstructured. Therefore, questions should be posed in such a way as to encourage the person being interviewed to give wide-ranging answers but within the context of the information needed by the interviewer. Conducting a good interview is not always easy. First, the interviewer must be familiar with the application domain. Second, there is no point in interviewing a member of the client organization if the interviewer already has made up his or her mind regarding the client’s needs. No matter what he or she previously has been told
or learned by other means, the interviewer must approach every interview with the intention of listening carefully to what the person being interviewed has to say while firmly suppressing any preconceived notions regarding the client company or the needs of the clients and potential uses of the software product to be built.
45
Scenarios.
A scenario is a way a user might utilize the target product to accomplish some objective. A scenario can be depicted in a number of ways. One technique is simply to list the actions comprising the scenario .Another technique is to set up a storyboard, a series of diagrams depicting the sequence of events.
They can demonstrate the behavior of the product in a way that is comprehensible to the user. This can result in additional requirements coming to light, as in the weight-loss planner example. Because scenarios can be understood by users, the utilization of scenarios can ensure that the client and users play an active role throughout the requirements analysis process. After all, the aim of the requirements analysis phase is to elicit the real needs of the client, and the only source of this information is the client and the users. Scenarios(or more precisely, use cases) play an important role in object-oriented analysis.
To send a questionnaire to the relevant members of the client organization.
This technique is useful when the opinions of, say, hundreds of individuals need to be determined. Furthermore, a carefully thought-out written answer may be more accurate than an immediate verbal response to a question posed by an interviewer. However, an unstructured interview conducted by a methodical interviewer who listens carefully and poses questions that expand on initial responses usually yields far better information than a thoughtfully worded questionnaire. Because questionnaires are preplanned, there is no way that a question can be posed in response to an answer. To examine the various forms used by the client.
For example, a form in a print shop might reflect press number, paper roll size, humidity, ink temperature, paper tension, and so on. The various fields in this form shed light on the flow of print jobs and the relative importance of the steps in the printing process. Other documents, such as operating procedures and job descriptions, also can be powerful tools for 3 finding out exactly what is done and how. Such comprehensive information regarding how the client currently does business can be extraordinarily helpful in determining the client’s
46
needs. Therefore, careful perusal of client documentation should never be overlooked as a source of information that can lead to an accurate assessment of the client’s needs.
To set up videotape cameras within the workplace to record (with the prior written permission of those being observed) exactly what is being done.
One difficulty of this technique is that it can take a long time to analyze the tapes. In general, one or more members of the requirements analysis team has to spend an hour playing back the tape for every hour that the cameras record. This time is in addition to what is needed to assess what was observed. More seriously, this technique has been known to backfire badly because employees may view the cameras as an unwarranted invasion of privacy. It is important that the requirements analysis team have the full cooperation of all employees; it can be extremely difficult to obtain the necessary information if people feel threatened or harassed. The possible risks should be considered carefully before introducing cameras or, for that matter, taking any other action that has the potential to anger employees.
An initial set of requirements has been elicited, the next step is to refine them, a process called requirements analysis. The members of the requirements team discuss the list of requirements with the various individuals interviewed to determine if anything has been omitted. Then, because the most accurate and powerful requirements analysis technique is rapid prototyping, a rapid prototype is built.
A rapid prototype is hastily built software that exhibits the key functionality of the target product. The client and intended users of the product now experiment with the rapid prototype, while members of the development team watch and take notes. Based on their hands-on experience, users tell the developers how the rapid prototype satisfies their needs and, more important, identify the areas that need improvement. The developers change the rapid prototype until both sides are convinced that the needs of the client are accurately encapsulated in the rapid prototype. The rapid prototype then is used as the basis for drawing up the specifications.
An important aspect of the rapid prototyping model is embodied in the word rapid. The
47
whole idea is to build the prototype as quickly as possible. After all, the purpose of the rapid prototype is to provide the client with an understanding of the product, and the sooner, the better. It does not matter if the rapid prototype hardly works, if it crashes every few minutes, or if the screen layouts are less than perfect. The purpose of the rapid prototype is to enable the client and the developers to agree as quickly as possible on what the product is to do. Therefore, any imperfections in the rapid prototype may be ignored, provided they do not seriously impair the functionality of the rapid prototype and thereby give a misleading impression of how the product will behave.
One difficulty with rapid prototyping is that the ease with which changes generally can be made to a rapid prototype may encourage the client to request all sorts of major changes to the delivered operational-quality version of the product. Furthermore, the client may expect the changes to be implemented as rapidly as changes to the rapid prototype. A related challenge is having to explain to the client that the rapid prototype is not of operational quality and the client will have to wait for the operational-quality version, even though the rapid prototype appears to do everything needed. Before rapid prototyping is used, it is 4 essential that the managers responsible for developing the product discuss these and related issues with the client. As with the introduction of any new technology, before an organization introduces the rapid prototyping model it is vital that management be aware of the advantages and disadvantages of rapid prototyping. In all fairness, although the case for rapid prototyping is strong, it has not yet been proven beyond all doubt.
Testing during the requirements phase .
Although the aim of the requirements phase is to establish the client’s real needs, usually
the client will not be the primary user of the target product. It therefore is essential to give the users the opportunity to experiment with the rapid prototype and suggest changes that, when approved by the client, will be implemented in the delivered version of the software product.
Therefore, the role of the software quality assurance group during the rapid prototyping phase is to ensure that the relevant individuals in the client organization have the opportunity
48
to interact with the rapid prototype and their suggestions actually reach the client or, perhaps, a committee of client managers responsible for analyzing the suggestions of the users.
Form the viewpoint of testing during the phases that are to come, it is essential that the requirements be traceable. To achieve this, the statements of the requirements need to be numbered to enable the SQA to trace them through the subsequent phases. The numbering should appear in the rapid prototype in the form of comments adjacent to the group of statements that implements each item in the requirements.
49
中文原文
C
C有一个静态，弱类型，类型系统，这与其他有共同之处。有内置类型对不同大小的整数,签署和无符号, 浮点数、字符和枚举类型( 枚举 )。 C99增加了一个 布尔数据类型，也有派生类型包括数组，指针，记录( 结构体 ),联合体。
C是经常使用在逃离类型系统的底层系统编程可能是必要的。编译器试图确保大多数类型的表达式的正确性,但程序员可以用不同的方法覆盖检查,要么通过使用类型转换显式地将一个值从一种类型转换为另一个,或者通过使用指针或工会重新诠释底层数据对象以其它方式。
一些人发现C的声明语法不直观,特别是 函数指针。(里奇的想法是在上下文中声明标识符类似于他们的使用:“声明反映了使用 ”。)
C的通常算术转换允许生成高效的代码，但有时会产生意想不到的结果。例如,签署和无符号整数的比较平等的宽度需要签署价值转化为无符号。这可以产生意想不到的结果,如果签署了价值是负的。
C支持使用指针，一个类型的参考记录的地址或一个物体的位置或函数在内存中。 指针可以 的引用 访问数据存储地址指出，或调用使用功能。指针可以使用赋值或操纵 指针的算术的运行时表示指针值通常是一个原始内存地址(也许加上一个offset-within-word字段)，但由于一个指针的类型包括指向的东西的类型，表达式包括指针可以在编译时类型检查。指针运算是由使用的大小自动缩放数据类型。 在C指针用于许多不同的目的。文本字符串通常使用指针操作的字符数组。动态内存分配使用指针来执行。许多数据类型，例如树通常实现为动态分配的结构体使用指针对象联系在一起。 指针是有用的函数作为参数传递给函数 高阶函数 (如qsort或BSEARCH )或回调 要调用的事件处理程序。
一个空指针价值明确指出,没有有效的位置。非关联化一个空指针值是未定义的,常常导致段错误。空指针的值是有用的指示等特殊情况下没有“下一个”最后一个节点的指针链表或者从函数返回指针指示错误。在适当的情况下在源代码，如分配一个指针变量, 空指针常量 可以写成0，有或没有显式转换为指针类型,或作为空宏定义的几个标准头文件。 在有条件的情况下，空指针值计算为false，而所有其他指针值评估为true。
空指针( void * )指出,未指定类型的对象,因此可以用作“通用的”数据指针。因为大小和类型的使用对象是未知的,无效指针不能反向引用,也不是指针算术上允许的,虽然他们可以很容易地(在很多情况下隐式)与任何其他对象指针类型转换。
粗心的使用指针是潜在的危险。因为他们通常不加以控制,一个指针变量可以指向任意位置,从而造成不良影响。虽然正确使用指针指向安全的地方,他们可以指出使用无效的不安全的地方 指针的算术，他们指出,可能被收回和重用的对象( 悬空指针 )，他们可以使用没有被初始化( 野指针 );或者他们可能直接分配一个不安全的使用价值，联盟，或通过另一个腐败的指针。 一般来说，C是宽容在允许操作和指针类型之间的转换,但编译器通常会提供选择不同程度的检查。 其他编程语言使用更严格的解决这些问题 参考 类型。
数组类型在C是一个固定的传统,在编译时静态指定大小。(最近C99标准还允许变长数组的一种形式。) 然而，也有可能分配一块内存(任意大小的)在运行时,使用标准库
50
的 malloc 功能,把它当作一个数组。 C数组和指针的统一意味着宣布这些动态分配的数组和模拟数组实际上是可以互换的。
因为数组总是访问(实际上)通过指针,数组访问一般不检查对底层数组大小,虽然有些编译器可以提供 边界检查 作为一个选项。 数组边界违规可能因此而在漫不经心地写代码，并可能导致各种影响,包括非法内存访问，腐败的数据,，缓冲区溢出和运行时异常。 如果所需的边界检查，必须手动完成的。
C没有特别规定宣布多维数组,而是依赖于递归在声明数组的数组的类型系统,有效地完成同样的事情。 产生的“多维数组的索引值可以被认为是在增加 row-major秩序 。
多维数组中常用数值算法(主要来自应用 线性代数 )存储矩阵。C数组的结构是适合这个特殊的任务。 然而,由于数组只是传递指针,数组的边界必须是已知的固定值或其他明确传递给任何需要它们的子例程，大小和动态数组的数组不能使用双索引访问。 (解决了这个分配与额外的行向量指针数组的列)。
C99引入了“变长数组”,解决一些,但不是全部，与普通C数组的问题。Array-pointer互换性的下标符号x( X 指定一个指针)语法为*(x + i)。( 32 ] 利用指针类型的编译器的知识，地址 x +我点是不基地址(指出 X )增加i字节, 而是定义的基地址递增i乘以一个元素的大小那X 点。因此，x指定的是数组的元素。
此外,在大多数表达式上下文(一个例外是操作数运算符 ),一个数组的名称自动转换为一个指针数组的第一个元素。 这意味着永远不会复制数组作为一个整体命名为一个函数的参数时,而是只通过了它的第一个元素的地址。因此,尽管函数调用在C语言中使用 pass-by-value 语义,数组是实际上通过参考 。
一个元素的大小可以确定通过应用操作符运算符任何的引用的元素 X ,如 n =运算符* x 或 n =运算符x[0] 和声明的数组中元素的数目一个可以确定为 sizeof / sizeof(0) 。后者 只有 适用于数组的名字:变量声明 下标 ( int[20] )。由于C语言的语义,它是不可能确定整个数组的大小通过指针数组或那些由动态分配( malloc ),代码等 sizeof arr / sizeof arr[0] ( arr =一个 指定一个指针)将不工作因为编译器假定指针本身是被请求的大小。( 33 ] ( 34 ] 因为数组名称参数 运算符 不是转换为指针,他们不表现出这种模棱两可。然而,由动态分配数组初始化指针,而不是真正的数组变量,所以他们遭受相同的运算符问题数组指针。
因此,尽管这个明显的数组和指针变量之间的等价性,还有他们之间的区别。即使数组的名称,在大多数表达式上下文,转换成一个指针(第一个元素),本身这个指针不占据任何存储;不是一个数组的名字 l-value ,其地址是一个 常数 ,不像一个指针变量。因此,数组“指向”无法改变,和不可能分配一个新地址数组的名字。 数组内容可能被复制,但是,通过使用 memcpy 功能,或者通过访问单个元素。
很多谜题都称为“完全联锁”。这意味着相邻块连接,这样如果你移动一个水平移动,保持连接。有时足够紧密的连接接拿着一块解决了部分。
拼图
一些完全联锁拼图块相似的形状,圆形标签在两端,切成相应的空格干预国接收相邻块的标签。 其它完全联锁谜题可能有制表符和空格安排在每一块,但他们通常有四条边,制表符和空格的数量从而增加到四个。 uniform-shaped完全联锁难题,有时被称为“日本风格”，是最困难的,因为形状之间的差异部分可以非常微妙的。
一些谜题也有部分non-interlocking方面，通常稍弯曲在复杂的曲线。 实际上这些
51
都是容易解决的难题，因为更少的其他部分则是潜在的候选人交配。
大多数拼图游戏广场、矩形或圆形，边缘部分，一边是直或顺利曲面创建这个形状,再加上四个角块如果拼图是正方形或长方形的。 一些七巧板一样有边缘部分，其余的联锁块,没有光滑的边缘,使它们更具挑战性。 其他游戏设计整个拼图形式图的形状，如一个动物。边缘部分更多的在这些情况下可能有不同的名称。
需求阶段，产品在时间和预算范围内正在开发的机会有点渺茫，除非软件开发团队的成员同意什么样的软件产品就行了。在实现这个一致的第一步是分析客户目前的情况尽可能准确。例如，它是不够的说，“他们需要一个计算机辅助设计系统，因为他们声称他们的手工设计系统，有糟糕。 “除非开发团队确切地知道什么是错的电流手工系统中，有一个高概率的新的计算机化系统的各个方面将同样”糟糕。 “同样，如果一台个人电脑制造商正在考虑一个新的操作系统的开发，第一步是评估企业目前的操作系统和仔细分析究竟为什么它是不能令人满意的。举一个极端的例子，这是至关重要知道是否只存在于销售经理，谁指责操作系统的销量不佳，还是操作系统的用户彻底与它的功能和可靠性醒悟头脑的问题。只有在目前的情况清晰的画面已经能够得到球队试图回答的关键问题，必须有什么新产品能够做到,回答这个问题的过程在需求阶段进行。
一种很普遍的误解是，在需求阶段，开发人员必须确定客户想要的软件。相反，在需求阶段的真正目的是确定客户需要什么软件。问题是，许多客户不知道他们需要什么。此外，即使谁拥有什么是需要一个好主意，一个客户可能难以准确地传达这些想法的开发商，因为大多数客户不太精通电脑比开发团队的成员。
为了激发客户的需求，要求团队成员必须熟悉应用程序域，也就是说，一般面积在其中提出的软件产品是被使用。例如，它不容易问一个银行家或护士的有意义的问题不先取得与银行或护理有一定的了解。因此，需求分析团队的每个成员的初始任务之一就是去熟悉的应用程序域，除非他或她已经在该股东方面的经验。使用正确的术语与所述目标软件的客户端和潜在用户进行通信时，这是特别重要的。毕竟，这是很难认真对待一个人在一个特定的领域工作，除非是面试官使用术语适用于该领域。
更重要的是，使用了不合适的话可能会导致一种误解，最终导致缺陷产品交付。可能会出现同样的问题，如果要求团队成员不了解域的术语的细微之处。解决与术语问题的一种方法是建立一个词汇表。初始条目插入而团队学习的应用程序域。那么词汇表被更新时要求团队成员遇到的新术语。不仅如此词汇减少客户和开发人员之间的混淆，这也就是在开发团队成员之间的误解，减轻有用。
一旦需求团队已经获得熟悉的领域，下一步就是他们开始以确定客户的需求，就是需求获取。启发式方法如下:
访谈。
要求团队成员与客户组织的成员见面，直到他们确信，他们已经引起了该产品的客户和未来用户的所有相关信息。有两种基本类型的面试，结构化和非结构化。在结构化面试，具体的，预先计划的，封闭式的问题被摆。在非结构化面试，开放式的提问方式，鼓励正在接受采访说出来的人。其中的一些事实可能不会来的光有采访过更有条理。与此同时，它不是一个好主意，如果面试过非结构化的。因此，问题应该提出这样的方式，以鼓励被采访给予广泛的答案，但所需的面试官的信息范围内的人。进行良好的采访并不容易。首先，面试者必须熟悉的应用程序域。第二，在面试客户组织的成员没有任何意义，如果面试官已经弥补了他或她的心就客户的需求。不管他或她先前已被告知或了
52
解到通过其他方式，面试官必须向每一个采访中仔细倾听被采访的人有说，同时坚决抑制有关客户公司或需要任何先入为主的观念意向客户端和软件产品要建的潜在用途。
方案。
一个方案是一种用户可能利用目标产品来完成一些目标。一个场景可以以多种方式进行描绘。一种方法是简单地列出包括在场景中的动作。另一种技术是建立一个脚本，一系列图表描绘事件的顺序的。
它们可以显示的方式，是可以理解的给用户的产品的行为。这可能会导致额外的要求来光，如在减肥计划者的例子。因为场景可以由用户理解，情景的利用率可以确保客户端和用户遍及需求分析过程中发挥积极作用。毕竟，需求分析阶段的目的是引起客户的真正需求，以及这些信息的唯一来源是客户端和用户。情景(或更精确地说，用例)在面向对象的分析中发挥重要作用。
要发送调查问卷给客户组织的相关成员。
需要的时候，比如说几百个人的意见，以确定这种技术是非常有用的。此外，经过深思熟虑的书面答复可能比立即口头回应面试官提出的问题更准确。然而，通过有条不紊的面试官谁听仔细，造成的扩大初步反应的问题进行了非结构化面试通常会产生比一个精心措辞的问卷更好的信息。因为问卷调查是预先计划的，没有办法，一个问题可以在响应一个答案被提出。为了检查由客户端使用的各种形式。
例如，在打印店形式可能反映按数字，纸卷尺寸，湿度，温度油墨，纸张的张力，等等。这种形式的各个领域阐明打印作业的流程，并在印刷过程中的步骤的相对重要性的光。其他文件，如操作程序及工作内容，也可以是功能强大的工具，找出到底是什么做，以及如何。关于如何在客户端目前并无业务，可在确定客户的需求非常有帮助，例如全面的信息。因此，详细阅读客户端文件不应该被忽视的信息源，可导致对客户的需求作出准确的评估。
要设置录像摄像机在工作场所录制(与被观察的事先书面许可)究竟正在做什么。
这种技术的一个困难是，它需要很长的时间来分析的磁带。一般来说，需求分析团队的一个或多个成员必须花一个小时播放磁带的每一个小时的摄像机记录。这一次是除了什么是需要评估什么进行了观察。更为严重的是，这种技术已经知道，事与愿违严重，因为员工可以查看相机作为一个无理侵犯隐私。该需求分析团队有全体员工的充分合作是很重要的;它可以是非常难以得到必要的信息，如果人们觉得受到威胁或骚扰。可能出现的风险，应引入相机或，对于这个问题，采取有激怒员工的潜力任何其他行动之前，请仔细考虑。
一组初始的需求已引起，下一步是改进它们，这个过程被称为需求分析。要求团队成员讨论的要求清单与采访，以确定是否有任何东西被省略了不同的个人。然后，因为最准确，最强大的需求分析技术是快速成型，快速原型构建。
一种快速原型是仓促建成的软件，表现出目标产品的关键功能。该产品的客户，并打算现在用户体验的快速原型，而开发团队成员的手表，并做笔记。根据他们的实践经验，用户告诉开发人员如何快速原型满足他们的需求，更重要的是，找出需要改善的地方。开发商改变快速原型，直到双方都坚信，客户的需求准确地封装在快速原型。快速原型然后被用作基础制定的规格。
快速原型模型的一个重要方面是体现在字快速。整个想法是尽快建立原型。毕竟，快速原型的目的是为客户端提供的商品有所了解，而且越早越好。这不要紧，如果快速
53
原型几乎没有工作，如果它崩溃每隔几分钟，或者如果屏幕布局是不完美的。快速原型的目的是使客户端和开发商尽快商定该产品是做什么的。因此，在快速原型任何瑕疵可以忽略不计，只要不严重影响了快速原型的功能，并由此得到的产物将如何表现一个错误的印象。
一个困难与快速原型是与一般改变的难易程度，可以向一个快速原型可能会鼓励客户要求的各种重大改变，产品的交付运营质量版本。此外，客户端可能期望的变化要尽可能快变化的快速原型实现。一个相关的挑战是不得不向客户解释该快速原型是运行质量不和客户端将不得不等待运行质量版本，即使快速原型用来做所需的一切。在快速成型时，它是重要的是负责开发产品讨论与这些客户端和相关问题的管理人员。正如引进任何新技术，组织介绍了快速原型模型之前，至关重要的是管理做到心中有数快速成型的优点和缺点。平心而论，尽管快速成型的情况下强，它尚未被证明毫无疑义。
在需求阶段测试。
虽然需求阶段的目的是建立客户的真实需求，通常客户端将不会是目标产品的主要用户。因此，至关重要的是让用户有机会体验快速原型和提出修改建议，当客户端获得批准，将在软件产品的交付版本中实现。
因此，在快速原型阶段的软件质量保证小组的职责是确保有关个人客户组织有机会与快速原型和他们互动的建议实际上到达客户端，或者也许是客户端的一个委员会管理者负责分析用户的建议。
在那些来相形成测试的观点来看，它是必不可少的要求是可追溯。为了实现这一目标，需要的规定的语句来进行编号，使SQA通过后续阶段来跟踪它们。编号应出现在快速原型在毗邻实现在要求每个项目组陈述意见的形式。
54
浙公网安备 33021202002483