同学录网站的设计与实现毕业设计(论文).doc

大连交通大学信息工程学院
毕业设计(论文)任务书

题 目 "一路顺风"同学录网站的设计与实现
任务及要求：　
1.设计（研究）内容和要求
任务：
1、 调查基于"一路顺风"同学录网站，完成实习报告，字数不少于3000，第三周交给指导老师。
2、 结合自己实习情况安排进度，填写进度计划表，第二周完成后交给指导老师签字，并严格执行。
3、 按照软件工程思想，独立完成系统的设计和程序开发，完成代码估计2000行左右。
4、 用JSP实现"一路顺风"同学录网站。
5、 程序简洁，算法可行，运行情况良好。

要求：
1、 每周和指导老师至少见面沟通一次，回报课题进展情况，接受老师询问。
2、 接到任务书后，查阅与题目及专业相关的外文资料进行翻译，要求不少于10000个外文字符，译出汉字不得少于3000，于第四周交给指导老师审阅。
3、 毕业设计第13周完成毕业论文的装订，并由指导老师评阅。论文要求12000字以上，包括综述、系统总体设计、系统实现、性能分析、结论等。
4、 教学第13周通过中软及教研室组织进行软件验收，验收时要提供软件使用说明书。
5、 于第13周提出毕业答辩申请并签字。
6、 第14 周答辩，要求制作PPT

2.原始依据
通过大学几年的学习，已经学习了诸如软件工程、数据库原理及应用、数据结构、C++、Visual Basic、JAVA等多门程序设计语言和网络等基础知识和专业知识，学生有能力而且可以独立完成小中型项目的设计与开发。学校现有设备和环境可以提供给学生实习和上机，而且具有专业老师可以指导学生。

3.参考文献
[1] 杨敏.王英华.Dreamweaver CS3.清华大学出版社.2009-04
[2] 张海藩.软件工程（第四版）.清华大学出版社.2003
[3] 吴洁明.袁山龙.软件工程应用实践教程[M].清华大学出版社.2005
[4] 廖彬山.高峰霞.JAVA动态系统开发教程.清华大学出版社.2008
[5] 孙卫琴. JAVA面向对象编程[M].电子工业出版社.2006
[6] 韩万江.姜立新.软件项目管理案例教程[M].机械工业出版社.2001
[7] 萨师煊.王珊.数据库系统概论[M].高等教育出版社.2002
[8] 潘凯华.李慧.刘欣等编著.MySQL快速入门.清华大学出版社.2012年1月
[9] 黄缙华等编著.MySQL入门很简单.清华大学出版社.2011年1月
[10] [美]Michael V. Mannino. Database Design. Application Development. and Administration Second Edition[M].电子工业出版社
[11] [美]Herbert Schidt著.Java参考大全.鄢爱兰译.清华大学出版社.2006

指导教师签字：
教研室主任签字：
　　　　　　　　　　　　　　　　　　　　　　　　年　　月　　日
大连交通大学信息工程学院
毕业设计(论文)进度计划与考核表
学生姓名
王淼
专业班级
软件工程
08-3班
指导教师
王 建
何丹丹
本课题其他人员
无
题　目
"一路顺风"同学录网站的设计与实现
日　期
计划完成内容
完成情况
指导老师检查签字
第1周
实习调研，查阅课题相关外文资料

第2周
了解行业状况、查阅文献资料，阅读资料，撰写调研报告

第3周
完成10000字符或3000汉字以上的外文翻译资料，准备资料，学习按时批技术

第4周
进行需求分析

第5周
进行概要设计

第6周
进行概要设计, 基本框架完成，提交毕业论文提纲

第7周
完成后台数据库的设计并编码，完成部分论文

第8周
完成前台界面的设计并编码，完成部分论文

第9周
继续编码并进行测试，继续编写毕业设计论文

第10周
继续进行程序测试，继续编写毕业设计论文

第11周
整理资料、文档、图表等，修改毕业设计论文

第12周
完成毕业设计论文，打印，按要求装订

第13周
软件验收和准备毕业设计答辩

第14周
毕业设计答辩及成绩评定

指导教师签字： 　　　　　　　　　　　 　　 年　　月　　日

大连交通大学信息工程学院
毕业设计(论文)外文翻译

学生姓名 王淼 专业班级 软件工程08-3班
指导教师 王建　何丹丹 职 称 高工　讲师
所在单位 　信息科学系软件工程教研室
教研室主任 　 刘瑞杰

完成日期 2012 年 4 月 13 日
Chapter 6 - Structures
A structure is a collection of one or more variables, possibly of different types, grouped together under a single name for convenient handling.(Structures are called ``records'' in some languages, notably Pascal.)Structures help to organize complicated data, particularly in large
programs, because they permit a group of related variables to be treated as a unit instead of as separate entities.
One traditional example of a structure is the payroll record: an employee is described by a set of attributes such as name, address, social security number, salary, etc. Some of these in turn could be structures: a name has several components, as does an address and even a salary. Another example, more typical for C, comes from graphics: a point is a pair of coordinate, a rectangle is a pair of points, and so on.The main change made by the ANSI standard is to define structure assignment-structures may be copied and assigned to, passed to functions, and returned by functions. This has been supported by most compilers for many years, but the properties are now precisely defined. Automatic structures and arrays may now also be initialized.
6.1 Basics of Structures
Let us create a few structures suitable for graphics. The basic object is a point, which we will assume has an x coordinate and a y coordinate,both integers.The two components can be placed in a structure declared like this:

Figure 6-1
struct point {
int x;
int y;
};
The keyword struct introduces a structure declaration, which is a list of declarations enclosed in braces. An optional name called a structure tag may follow the word struct (as with point here). The tag names this kind of structure, and can be used subsequently as a shorthand for the part of the declaration in braces.
The variables named in a structure are called members. A structure member or tag and an ordinary (i.e., non-member) variable can have the same name without conflict, since they can always be distinguished by context.Furthermore, the same member names may occur in different structures,although as a matter of style one would normally use the same names only
for closely related objects.
A struct declaration defines a type. The right brace that terminates the list of members may be followed by a list of variables, just as for any basic type. That is,struct { ... } x, y, z;
is syntactically analogous to int x, y, z;in the sense that each statement declares x, y and z to be variables of the named type and causes space to be set aside for them.A structure declaration that is not followed by a list of variables reserves no storage; it merely describes a template or shape of a structure.If the declaration is tagged, however, the tag can be used later in definitions of instances of the structure. For example, given the declaration of point above,
struct point pt;defines a variable pt which is a structure of type struct point. A structure can be initialized by following its definition with a list of initializers, each a constant expression, for the members:
Struct maxpt = { 320, 200 };
An automatic structure may also be initialized by assignment or by calling a function that returns a structure of the right type.A member of a particular structure is referred to in an expression by a construction of the form structure-name.member The structure member operator ``.'' connects the structure name and the member name. To print the coordinates of the point pt, for instance,printf("%d,%d", pt.x, pt.y);or to compute the distance from the origin (0,0) to pt,double dist, sqrt(double);dist = sqrt((double)pt.x * pt.x + (double)pt.y * pt.y);Structures can be nested. One representation of a rectangle is a pair of points that denote the diagonally opposite corners:

Figure 6-2
struct rect {
struct point pt1;
struct point pt2;
};
The rect structure contains two point structures. If we declare screen as struct rect screen;then screen.pt1.x refers to the x coordinate of the pt1 member of screen.
6.2 Structures and Functions
The only legal operations on a structure are copying it or assigning to it as a unit, taking its address with &, and accessing its members. Copy and assignment include passing arguments to functions and returning values from functions as well. Structures may not be compared. A structure may be initialized by a list of constant member values; an automatic
structure may also be initialized by an assignment.Let us investigate structures by writing some functions to manipulate points and rectangles. There are at least three possible approaches: pass components separately, pass an entire structure, or pass a pointer to it.Each has its good points and bad points.The first function, makepoint, will take two integers and return a point structure:
/* makepoint: make a point from x and y components */
struct point makepoint(int x, int y)
{
struct point temp;
temp.x = x;
temp.y = y;
return temp;
}
Notice that there is no conflict between the argument name and the member with the same name; indeed the re-use of the names stresses the relationship.makepoint can now be used to initialize any structure dynamically, or to provide structure arguments to a function:
struct rect screen;
struct point middle;
struct point makepoint(int, int);
screen.pt1 = makepoint(0,0);
screen.pt2 = makepoint(XMAX, YMAX);
middle = makepoint((screen.pt1.x + screen.pt2.x)/2,
(screen.pt1.y + screen.pt2.y)/2);
The next step is a set of functions to do arithmetic on points. For
instance,
/* addpoints: add two points */
struct addpoint(struct point p1, struct point p2)
{
p1.x += p2.x;
p1.y += p2.y;
return p1;
}
Here both the arguments and the return value are structures. We incremented the components in p1 rather than using an explicit temporary variable to emphasize that structure parameters are passed by value like any others.As another example, the function ptinrect tests whether a point is inside a rectangle, where we have adopted the convention that a rectangle
includes its left and bottom sides but not its top and right sides:
/* ptinrect: return 1 if p in r, 0 if not */
int ptinrect(struct point p, struct rect r)
{
return p.x >= r.pt1.x && p.x < r.pt2.x
&& p.y >= r.pt1.y && p.y < r.pt2.y;
}
This assumes that the rectangle is presented in a standard form where the pt1 coordinates are less than the pt2 coordinates. The following function returns a rectangle guaranteed to be in canonical form:
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
/* canonrect: canonicalize coordinates of rectangle */
struct rect canonrect(struct rect r)
{
struct rect temp;
temp.pt1.x = min(r.pt1.x, r.pt2.x);
temp.pt1.y = min(r.pt1.y, r.pt2.y);
temp.pt2.x = max(r.pt1.x, r.pt2.x);
temp.pt2.y = max(r.pt1.y, r.pt2.y);
return temp;
}
If a large structure is to be passed to a function, it is generally more efficient to pass a pointer than to copy the whole structure. Structure pointers are just like pointers to ordinary variables. The declaration struct point *pp;says that pp is a pointer to a structure of type struct point. If pp points to a point structure, *pp is the structure, and (*pp).x and (*pp).y are the members. To use pp, we might write, for example,
struct point origin, *pp;
pp = &origin;
printf("origin is (%d,%d)\n", (*pp).x, (*pp).y);
The parentheses are necessary in (*pp).x because the precedence of the structure member operator . is higher then *. The expression *pp.x means *(pp.x), which is illegal here because x is not a pointer.Pointers to structures are so frequently used that an alternative notation is provided as a shorthand. If p is a pointer to a structure, then p->member-of-structure refers to the particular member. So we could write instead
printf("origin is (%d,%d)\n", pp->x, pp->y);
Both . and -> associate from left to right, so if we have
struct rect r, *rp = &r;
then these four expressions are equivalent:
r.pt1.x
rp->pt1.x
(r.pt1).x
(rp->pt1).x
The structure operators . and ->, together with () for function calls and [] for subscripts, are at the top of the precedence hierarchy and thus bind very tightly. For example, given the declaration
struct {
int len;
char *str;
} *p;
then
++p->len
Increments len, not p, because the implied parenthesization is ++(p->len).Parentheses can be used to alter binding: (++p)->len increments p before accessing len, and (p++)->len increments p afterward. (This last set of parentheses is unnecessary.) In the same way, *p->str fetches whatever str points to; *p->str++ increments str after accessing whatever it points to (just like *s++);(*p->str)++ increments whatever str points to; and *p++->str increments p after accessing whatever str points to.
6.3 Arrays of Structures
Consider writing a program to count the occurrences of each C keyword.We need an array of character strings to hold the names, and an array of integers for the counts. One possibility is to use two parallel arrays,keyword and keycount, as in char *keyword[NKEYS];
int keycount[NKEYS];But the very fact that the arrays are parallel suggests a different organization, an array of structures. Each keyword is a pair:
char *word;
int cout;
and there is an array of pairs. The structure declaration
struct key {
char *word;
int count;
} keytab[NKEYS];
Declares a structure type key, defines an array keytab of structures of
this type, and sets aside storage for them. Each element of the array is
a structure. This could also be written
struct key {
char *word;
int count;
};
struct key keytab[NKEYS];
Since the structure keytab contains a constant set of names, it is easiest to make it an external variable and initialize it once and for all when it is defined. The structure initialization is analogous to earlier ones - the definition is followed by a list of initializers enclosed in braces:
struct key {
char *word;
int count;
}
keytab[] = {
auto", 0,
"break", 0,
"case", 0,
"char", 0,
"const", 0,
"continue", 0,
"default", 0,
/* ... */
"unsigned", 0,
"void", 0,
"volatile", 0,
"while", 0
};
The initializers are listed in pairs corresponding to the structure members. It would be more precise to enclose the initializers for each "row" or structure in braces, as in
{ "auto", 0 },
{ "break", 0 },
{ "case", 0 },
...
But inner braces are not necessary when the initializers are simple variables or character strings, and when all are present. As usual, the number of entries in the array keytab will be computed if the initializers are present and the [] is left empty.The keyword counting program begins with the definition of keytab. The main routine reads the input by repeatedly calling a function getword that fetches one word at a time. Each word is looked up in keytab with a version of the binary search function that we wrote in Chapter 3. The list of keywords must be sorted in increasing order in the table.
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#define MAXWORD 100
int getword(char *, int);
int binsearch(char *, struct key *, int);
/* count C keywords */
main()
{
int n;
char word[MAXWORD];
while (getword(word, MAXWORD) != EOF)
if (isalpha(word[0]))
if ((n = binsearch(word, keytab, NKEYS)) >= 0)
keytab[n].count++;
for (n = 0; n < NKEYS; n++)
if (keytab[n].count > 0)
printf("%4d %s\n",
keytab[n].count, keytab[n].word);
return 0;
}
/* binsearch: find word in tab[0]...tab[n-1] */
int binsearch(char *word, struct key tab[], int n)
{
int cond;
int low, high, mid;
low = 0;
high = n - 1;
while (low <= high) {
mid = (low+high) / 2;
if ((cond = strcmp(word, tab[mid].word)) < 0)
high = mid - 1;
else if (cond > 0)
low = mid + 1;
else
return mid;
}
return -1;
}
We will show the function getword in a moment; for now it suffices to say that each call to getword finds a word, which is copied into the array named as its first argument.The quantity NKEYS is the number of keywords in keytab. Although we could count this by hand, it's a lot easier and safer to do it by machine,especially if the list is subject to change. One possibility would be to terminate the list of initializers with a null pointer, then loop along keytab until the end is found.
But this is more than is needed, since the size of the array is completely determined at compile time. The size of the array is the size of one entry times the number of entries, so the number of entries is just size of keytab / size of struct key C provides a compile-time unary operator called sizeof that can be used to compute the size of any object. The expressions sizeof object and sizeof (type name) yield an integer equal to the size of the specified object or type in bytes.(Strictly,