堆栈4
第四章堆栈
栈和队列是程序设计中经常使用数据结构。本章先介绍栈的结构、实例及应用。
4.1栈的定义
栈是一种特殊的线性表，其插入和删除只允许在线性表的一端进行。允许操作的一端称为栈顶（top），另一端称为栈底（bottom）。栈的插入操作称为入栈（push），删除操作称为出栈（pop），当栈中没有元素时为空栈。
由于只允许在栈顶进行插入和删除，每次删除的总是最后插入的数据元素，因此栈又称为“后进先出表”（LIFO表）。
4.2用数组模拟堆栈
堆栈数组的声明如下：
Int stack[maxsize];
Int top=-1;
其中maxsize是堆栈的最大容量。
下面介绍在堆栈中对数据的存取操作
1．入栈操作
Push只要有两步操作：
（1）栈顶指针：top+1；
（2）若top≤maxsize，则将数据存入top所指的数组元素中，否则栈已满。
2．出栈操作
Pop的处理有以下两步：
（1）若栈顶指针top≥0，则取出栈顶指针top所指的数组内容；
（2）将栈顶指针：top-1，指向下一个元素。
3．使用数组实现堆栈的操作
程序源代码
01//= = = = = = = = = Program Description= = = = = = = = = = = = = = = = = = = =
02//程序名称：Stack01.java
03//程序目的：堆栈数据的存取（使用数组）
04//Written By Kuo-Yu Huang.(WANT Studio.)
05//= = = = = = = = = = = = = = = = = = = = = = = = = = = = =
06import ConsoleReader.*; //引入已定义的数据输入类
07
08puplic class Stack01
09{
10puplic static void main (string args[ ])
11{
12int Select; //选择功能变量
13StackArray Stack01=new StackArray(); //堆栈数组
14int I; //循环计数变量
15int Value; //输入值变量
16
17do
18{
19System.out.println(―(1)Input a stack data‖);
20System.out.println(―(2)Output a stack data‖);
21System.out.println(―(3)Exit‖);
22System.out.println(―Please select one=>‖);
23ConsoleReader console =new ConsoleReader (System.in); 24Select=console.resdInt();
25
26switch (Select) //判断选择的功能
27{
28case1:
29System.out.print(―Please input the data=>‖); 30Value =console.readInt();
31Stack01.print();
32Stack01.Push(V alue);
33Stack01.Print();
34break;
35case2:
36Stack01.Print();
37value=Stack01.Pop();
38Stack01.Print();
39break;
40}
41}while (Select!=3);
42}
43}
44
45class StackArray
46{
47int MaxSize=10;
48int[ ]Astack=new int[MAXsize]; //声明堆栈数组
49int Top=-1 //堆栈顶端
50//-----------------------------------------------------------------------
51//输出堆栈数据
52//-------------------------------------------------------------------------
53puplic void Push(int V alue)
54{
55int I; //循环计数变量
56
57System.out.println(―The stack content before(top->bottom):‖); 58for(I=Top;I>=0; I--)
59System.out.println(―[―+Astack[I]+‖]‖);
60System.out.println(―‖);
61}
62
63//---------------------------------------------------------------------
64//存入堆栈数据
65//--------------------------------------------------------------------------
66puplic void Push(intVaule)
67{
68int I;
69
70if(Top>=MaxSize) //判断是否已超出堆栈最大容量71System.out.println(―The stack is full!!‖);
72else
73{
74Top++; //栈顶指针+1
75Astack[Top]=Vaule; //将数据存入堆栈中76}
77}
78
79//-----------------------------------------------------------------------
80//从堆栈中取出数据
81//----------------------------------------------------------------------
82puplic int Pop()
83{
84int Temp; //暂存从堆栈中去出来的数据
85int I; //循环计熟变量
86
87if (Top <0) //判断堆栈是否为空
88{
89System.out.primtln(―The stack is empty!!‖);
90return-1;
91}
92
93
94Temp=Astack[Top]; //将取出数据暂存于变量中95Top--; //栈顶指针-1
96
97returnTemp;
98}
99}
4.3使用Stack类
在Java语言中，提供了一个Stack类供程序设计者在程序设计中使用堆栈。这里节录了Java.utility中Stack类的使用方法及方法的功能。
●Stack类的使用方法
import java.util.stack;
●Stack类的构造方法
Stack（）：建立一个空的堆栈
●Stack类的方法
public object push(objact item)
public synchronized object pop()
public synchronized peek()
public boolean empty()
public synchronized int search(object o)
下面用实例说明使用Stack类进行堆栈的数据存取
程序源代码
01//= = = = = = = = = Program Description= = = = = = = = = = = = = = = = = = = =
02//程序名称：Stack02.java
03//程序目的：堆栈数据的存取（使用Stack类）
04//Written By Kuo-Yu Huang.(WANT Studio.)
05//= = = = = = = = = = = = = = = = = = = = = = = = = = = = ================
06 import ConsoleReader.*; //引入已定义的数据输入类
07imput java 。util。stack //引入Stack类
08
09uplic class Stack02
10{
11puplic static void main (string args[])
12{
13StackArray Stack01=new StackArray(); //堆栈变量
14int I; //循环计数变量
15
16System .out.println(―The Stack Content {Bottom ->Top}‖)；
17System .out println (―Push 0,1,2,3,4,5to the Stack ‖)；
18for （I = 0 ；I<6；I ++）
19{
20System .out.println(―[―+I+‖]；
21Stack01.push(new Integer);
22}
23
24System .out.println(―‖)；
25System.out.println(―The Stack Content
26System.out.println(―Pop all data in the Stack‖)；
27for （I=0 ；I〈6；I++〉
28System .out.println(―[‖+Stack01.pop()‖]‖);
29}
30
31｝
4.4堆栈的应用
4．4．1表达式的表示
一个表达式是由操作数、运算符及分隔符组成的。我们按照运算符在表达式中的位置将表达式分为中缀表达式、后缀表达式和前缀表达式。
例如有表达式：X/（Y-Z）
后缀表达式为：XYZ-/
前缀表达式为：/X-YZ
4．4．2中缀表达式的表示与计算
1．中缀表达式的计算步骤
对表达式从左向右读取，因为要考虑到运算符的优先级，需要两个堆栈分别存放运算符和操作数。中缀表达式的计算步骤如下：
（1）建立操作数和运算符堆栈，初始为空；
（2）当表达式未读完
●若读取的是操作数，则压入操作数栈
●若读取的是运算符：
若运算符栈为空，则将其压入运算符栈；否则，则和栈顶运算符比较优
先级，若较栈顶的高，则直接压入堆栈中；若较栈顶低，从运算符堆栈
中取出一个运算符，从操作数堆栈中取出所需的操作数，进行计算以后
将结果压入操作数堆栈中。
2．程序实现
01 //====================Program Description===============
02 //程序名称:Stack03.java
03 //程序目的:输入一个中序表达式,并计算其值
04//Written By Kuo-Yu Huang .(W ANT Studio.)
05 //==================================================
06 import ConsoleReader.*; //引入已定义的数据输入类
07
08public class stack03
09{
10public stsck void main (String args[ ])
11{
12StackArray Opeator = new StackArray(); //运算符堆栈
13StackArray Operand = new StackArray(); //操作数堆栈
14String Expression = new String ()；//声明表达式字符串
15Int Position = 0 ; //表达式位置
16Int Operator1; //运算符
17 int operand1 = 0; //前操作数
18 int operand1 = 0; //后操作数
19 int Evaluate = 0 ; //运算结果
20
21System.out .println(―Please input the inorder expression :‖);
22//读取中序表达式存入字符串
23ConsoleReader console = new ConsoleReader (System.in );
24Expression = console .readLine()；
25
26while (true )
27{
28//判断是否为运算符
29if Opeator.IsOperator(
30{
31if (Operator. Top ! = -1);
32{
33if (Operator .Priority (
34<=Operator .Priority(Opeartor.Astack[Opeartor.Top ])) 35{
36//从堆栈中取出两个操作数和一个运算符
37Operand1 = Operand.Pop ()；
38Operand２= Operand.Pop ()；
39Operand1 = Operand.Pop ()；
40
41Operator.Push(Operaand.TwoResult(Operator1.Operator1Operator2) ) 42}
43}
44//存入运算符堆栈
45Operand.Push ((int) (Expression.charAt(Position ) );
46}
47else
48{
49//存入操作数堆栈——需做ASCII码转换
50Operand.Push ((int) (Expression.charAt(Position )-48) );
51}
52Position++；
53If （Position ）= Expression .length() )
54Break;
55}
56//取出运算符堆栈的内容
57while (Operator .Top != -1)
58{
59Operator1 = Ooerator.Pop ()；
60Operrator1 = Operand.Pop ()；
61 Operator 2 = Opearand.Pop ；
62 //后两个操作数计算后结果存入堆栈
63
64Operator..TwoResult(Operator1.Operator1Operator2) );
65}
66//取出表达式最终结果
67Evaluate = Operator .Pop ()；
68System.out.print(―The expression [―+Expression‖]‖);
69System.out.println(―result is ‖+Evaluate);
70}
71}
72
73class StackArray
74{
75int MaxSize = 20 ;
76int [ ] Astack =new int [ MaxSize ]; //声明堆栈数组
77int Top = -1 ; //初始化栈顶指针
78
79//-----------------------------------------------------------------------------------
80//存入堆栈数据
81//-----------------------------------------------------------------------------------
82public void Push (int Value )
83{
84int I ;
85
86if (Top >=MaxSize ) //判断是否已超出堆栈最大容量87System .out.println(―The stack is full!!‖)；
88Else
89{
90Top ++；
91AStack [Top ] = Value ；//将数据存入堆栈中
92}
93}
94
95 //——————————————————————————————
96 //从堆栈中取出数据
97 //——————————————————————————————
98public int Pop （）
99{
100Int Temp ；//暂存从堆栈取出来的数据
101Int i‘//循环计数变量
102
103If （Top <0）///判断堆栈是否为空
104{
105System .out.println(The stack is empty !!‖)
106Return -1；
107}
108
109Temp = AStack [Top]；
110Top--；//栈顶指针-1
111
112Return Temp ；
113}
114
115//--------------------------------------------------------------------------------------
116//判断是否为运算符
117//---------------------------------------------------------------------------------------
118public boolean IsOperator （int Operator ）
119{
120
121If （Operator ==43|| Operator ==45）
122|| Operator ==42 || Operator ==47 }
123return true ;
124else
125return false ;
126}
127
128//-----------------------------------------------------------------------------------
129//判断运算符的优先权
130//--------------------------------------------------------------------------------------
131Public int Priority (int operator)
132{
133if ( operator == 43 || operator == 45 ) //+ -运算符
134return 1 ；
135else if （operator ==42 || operator == 47 ）//*/运算符
136return 2 ；
137else
138return 0；
139}
140
141//------------------------------------------------------------------------------------------------ 142对任意两个操作数进行运算并求值
143//------------------------------------------------------------------------------------------------ 144public int TwoResult （int operator，int operand1，int operand2 ）145{
146switch （operator ）
147{
148case 43：
149return （operand2 + operand1 ）；
150case 45：
151return （operand2 – operand1 ）；
152case 42：
153return （operand2 *operand1 ）
154case 47；
155return （operand2 / operand1）；
156}
157return 0
158}
159}
4．4．3前缀表达式的表示与计算
1.前缀表达式的计算步骤
由于前缀表达式中无括号，也就不用考虑优先级问题。所以前缀表达式的计算只需要一个操作数栈。
前缀表达式的处理步骤如下：
（1）建立操作数栈，初始为空；
（2）当表达式未读完：（由右至左）读取一个运算单元
●若读的是操作数，则将其存入操作数栈；
●若读取的是运算符，则从操作数栈中取出所需的操作数进行计算，并将计算结
果压入堆栈中。
2．程序实现
01//============ProgramDescripyion =======================================
02 //程序名称:Stack04 .java
03 //程序目的:输入一前序表达式,并计算其值
04 //Written By Yu –Huang.(WANT Studio .)
05//===================================================================
06 import ConsoleReader.*；//引入已定义的数据类
07
08public class Stack04
09{
10Public stack void main （String args [ ]）
11｛
12StackArray Prefix = new StackArray（）；//前序表达式堆栈
13StackArray Operand = new StackArray（）；//操作数堆栈
14String Expression = new String （）；//声明表达式字符串
15int Position = 0 ；//表达式位置
16int Operator 1；//运算符
17int Operand1 = 0 ；//前操作数
18int Operand2 = 0 ；//后操作数
19int Evaluate = 0 ；//运算结果
20int Token = o ；//输出字符
21
22System .out.print(―Please input the preorder expression :‖);
23//读取前序表达式存入字符串
24ConsoleReader console = new ConsoleReader (System,in);
25Expression = console .readline( );
26
27while ( true )
28{
29if (Expression .chatAt (Position )<‘0‘)
30Prefix.Push(int)Expression .charAt(Position ) );
31else
32prefix .push ((int)
33Expression.charAt(Position)-48);
34Position++;
35if(Position>=Expression.length())
36break;
37}
38//取出表达式堆栈的内容
39while (Prefix.Top!=-1)
40{
41Token=Prefix.Pop(); //先取出一个数据值
42
43
44if(Prefix.IsOperator(Token))//判断是否为运算符
45{
46Operand1=Operand.Pop();
47Operand2=Operand.Pop();
48//计算后两操作数后存入堆栈
49Opreand.Push(Operand.TwoResult(Token,Operand1,Operand2)); 50}
51else
52//存入操作数堆栈—需做ASCII码转换53Operand.Push(Toke)
54}
55//取出表达式最终结果
56Evaluate=Operand.Pop();
57System.out.print(―The expression[―+Expression+‖]‖);
58System.out.println(―result is‖+Evaluate);
59}
60}
61
62class StackArray
63{
64int MaxSize=20;
65int[] Astack=new int[MaxSize]; //声明堆栈数组
66int Top=-1; //初始化栈顶指针
67
68//------------------------------------------------------------------------------------------------------------- 69//存入堆栈数据
70//------------------------------------------------------------------------------------------------------------- 71public void Push(int Value)
72{
73int i;
74
75if(Top>=MaxSize) //判断是否已超出堆栈最大容量
76System.out.println(―The stack is full!!‖);
77else
78{
79Top++; //栈顶指针+1
80Astack[Top]=Value; //将数据存入堆栈中
81}
82}
83
84//-------------------------------------------------------------------------------------------------------
85//从堆栈中取出数据
86//------------------------------------------------------------------------------------------------------
87public int Pop()
88{
89int Temp; //暂存从堆栈取出来的数据
90int i; //循环计数变量
91
92if(Top<0) //判断堆栈是否为空
93{
94System.out.println(―The Stack is empty!!‖);
95return –1;
96}
97
98Temp=Astack[Top]; //将取出数据暂存于变量中
99Top--; //栈顶指针-1
100
101Return Temp;
102}
103
104//--------------------------------------------------------------------------------------------------------- 105//判断是否为运算符
106//----------------------------------------------------------------------------------------------------------- 107public boolean IsOperator(int Operator)
108{
109
110if(Operator==43||Operator==45
111||Operator==42||Operator==47)
112return true; //+-*/运算符
113else
114return false;
115}
116
117//------------------------------------------------------------------------------------------------------ 118//判断运算符的优先权
119//------------------------------------------------------------------------------------------------------- 120public int Priority(int operator)
121{
122if(operator==43||operator==45) //+-运算符
123returnj 1;
124else if(operator==42||operator==47) //*/运算符
125return 2;
126else
127return 0;
128}
129
130//-----------------------------------------------------------------------------------------------
131//对任意两个操作数进行运算并求值
132//-----------------------------------------------------------------------------------------------
133public int TwoResult(int operator,int operand1,int operand2)
134{
135switch(operator)
136{
137case43:
138return(operand2+operand1);
139case45:
140return(operand2-operand1);
141case42:
142return(operand2*operand1);
143case47:
144return(operand2/operand1);
145}
146return 0;
147}
148}
4．4．4后缀表达式的表示与实现
1．后缀表达式的处理步骤
后缀表达式的计算与前缀表达式相同，惟一不同的是读取表达式的方向和前缀表达式相反，是由左至右读取数据。
处理步骤如下：
（1）建立操作数栈，初始为空；
（2）当表达式未读完：（由左至右）读取一个运算单元
●若读的是操作数，则将其存入操作数栈；
●若读取的是运算符，则从操作数栈中取出所需的操作数进行计算，并
将计算结果压入堆栈中。
2．程序实现
01 //= = = = = = = = = = = = Program Description= = = = = = = = = = = = = = = = =
02 //程序名称：Stack05.java
03 //程序目的：输入一后序表达式，并计算其值
04 //Written By Kuo-Yu Huang.(WANT Studio.)
05 //= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
06 import ConsoleReader.*; //引入已定义的数据输入类
07
08 public class Stack05
09 {
10 public static void main(String srgs[])
11 {
12 StackArray Operand=new StackArray(); //操作数堆栈
13 String Expression=new String(); //声明表达式字符串
14 Int Position=0; //表达式位置
15 Int Operand1=0; //前操作数
16 Int Operand2=0; //后操作数
17 Int Evaluate=0; //运算结果
18
19 System.out.print(―Please input the postorder expression:‖);
20 // 读取后序表达式存入字符串
21 ConsoleReader console=new ConsoleReader(System.in);
22 Expression=console.readline();
23
24 while(true)
25 {
26 //判断是否为运算符
27 if(Operand.IsOperator(Expression.charAt(Position)))
28 {
29 Operand1=Operand.Pop();
30 Operand2=Operand.Pop();
31 //计算后两操作数后存入堆栈
32 Operand.Push(Operand.twoResult(
33 Expression.charAt(Position),Operand1,Operand2));
35 else
36 //存入操作数堆栈—需做ASCII码转换
37 Operand.Push(Expression.charAt(Position)-48);
38 Position++;
39 If(Position>=Expression.length())
40 break;
41 }
42
43 //取出表达式最终结果
44 Evaluate=Operand.Pop();
45 System.out.Println(―The expression[―+Expression+‖]‖);
46 System.out.println(―result is ‖+Evaluate);
47 }
48 }
49
50 class StackArray
51 {
52 int MaxSize=20;
53 int[]Astack=new int[MaxSize]; //声明堆栈数组
54 int Top=-1; //初始化栈顶指针
55
56 //----------------------------------------------------------------
57 //存入堆栈数据
58 //----------------------------------------------------------------
59 public void Push(int Value)
60 {
61 int i;
62
63 if(Top>=MaxSize)
64 System.out.println(―The stack is full!!‖);
65 Else
66 {
67 Top++;
68 Astack[Top]=Value;
69 }
70 }
71
72 //--------------------------------------------------------------------
73 //从堆栈中取出数据
74 //-------------------------------------------------------------------
75 public int Pop()
76 {
77 int Temp;
79
80 if(Top<0)
81 {
82 System.out.println(―The stack is empty‖);
83 return –1;
84 }
85
86 Temp=Astack[Top];
87 Top--;
88
89 return Temp;
90 }
91
92 //-----------------------------------------------------------
93 // 判断是否为运算符
94 //-----------------------------------------------------------
95 public Boolean IsOperator(int Operator)
96 {
97
98 if(Operator==43|| Operator==45
99 || Operator==42|| Operator==47)
100 return true;
101 else
102 return false;
103 }
104
105 //------------------------------------------------------------
106 // 判断运算符的优先权
107 //------------------------------------------------------------
108 public int Priority(int operator)
109 {
110 if(operator==43|| operator45)
111 return 1;
112 else if(operator==42|| operator==47)
113 return 2;
114 else
115 return 0;
116 }
117
118 //----------------------------------------------------------
119 // 对任意两个操作数进行运算并求值
120 //----------------------------------------------------------
121 public int TwoResult(int operator,int operand1,int operand2)
123 switch(operator)
124 {
125 case 43:
126 return(operand2+operand1);
127 case 45:
128 return(operand2-operand1);
129 case 42:
130 return(operand2*operand1);
131 case 47:
132 return(operand2/operand1);
133 }
134 return 0;
135 }
136 }
4．4．5表达式的转换
我们可以看到，前缀、后缀表达式的计算相对简单，而我们习惯用中缀表达式表示，下面介绍中缀表达式与后缀表达式的转换。
1．转换原则
假如有一个中缀表达式，将其转换成后缀表达式的原则如下：
（1）从左至右读取一个字符；
（2）若读取的是操作数，则直接输出；
（3）若读取的是运算符：
●该运算符是“(”，则直接压入栈；
●该运算符为“）”，则输出堆栈中的右运算符，直到取出左括号为止；
●该运算符为非括号运算符，则与栈顶的运算符比较优先级：若较栈顶的高
或相等，则直接压入栈；若较栈顶的低，则输出堆栈中的运算符。
（4）当表达式读完，而堆栈中尚有运算符，则依次取出，直到栈空。
2．程序实现
程序源代码
01//========program description==============
02//程序名称：stack06.java
03//程序目的：中序表达式转后序表达式
04//written by kuo-yu huang.(want studio.)
05//==========================================================
06import consolereader.*
07
08public class stack06
09{
10public static void main (string args[ ])
11{
12stackarray operator=new stackarray ()
13string inorder=new string();
14int inposition=0
15int operatorl=0
16
17ystem.out.print (―please input the inorder expression:‖);
18
19consolereader console =new consolereader (system.in);
20 inorder =console.readline();
21
22 system.out.print(―the postorder expression is [‖];
23 while (ture0;
24{
25
26if (operator.isoperator(inorder.charat(inposition)))
27{
28 if (operator. Isoperator (inorder .charat(inposition ))) 29?(?)
30
31erator.push (inorder.charat (inposition));
32 else
33{
34((char ) inorder.charat (inposition));
35
36
37 if {o perator.astack(operator.top)!=40}
38{
39operator1=operator.pop();
40system.out.print ((char)operator1);
41}
42}
43else
44{
45if {operator. Priority {inorder.charat (inposition)};
46<=
47operator. Priority(operator.astack(operator.top))
48&& operator. Top !=-1}
49{
50operator1=operator.pop();
51if(Operator ! = 40 )
52System.out.print((char)Operator);
53}
54Operator.Push(Inorder.charAt(InPosition));
55}
56}
57}
58else
59System.out.print(Inorder.chaiAt(InPositing));
60InPsition++;
61if ( InPosition >= Inorder.length() )
62break;
63}
64
65while ( Operator.Top != -1 ) //取出堆栈中所有的运算符
66{
67Operator1 = Operator.Pop();
68System.out.print((char(Operator1);
69}
70System.out.println( ―[‖];
71}
72}
73
74class StackArray
75{
76int MaxSize = 20;
77int [] Astack = new int [MaxSize]; //声明堆栈数组
78int Top = -1; //初始化栈顶指针
79
80//---------------------------------------------------------
81//存入堆栈数据
82//----------------------------------------------------------
83public viod Push(int Value)
84{
85int I;
86
87if (Top >=MaxSize) //判断是否已超出堆栈最大容量88System.out.println(―The stack is full!!‖);
89else
90{
91Top++; //栈顶指针+1
92Astack[Top] = Value; //将数据存入堆栈中
93}
94}
95
96//---------------------------------------------------
97 //从堆栈中取出数据
98//----------------------------------------------------
99public int Pop()
100{
101int Temp; //暂存从堆栈取出来的数据
102int I; //循环计数变量
103
104if (Top<0 ) //判断堆栈是否为空
105{
106System.out.println(―The stack is empty!!‖);
107return –1;
108}
109
110Temp = Astack[Top]; //将取出数据暂存于变量中111Top - -; //栈顶指针-1
112
113return Temp;
114}
115
116//---------------------------------------------------------------
117// 判断是否为运算符
118//----------------------------------------------------------------
119public Boolean IsOperator (int Operator)
120{
121
122if ( Operator = = 43 | | Operator = = 45
123| | Operator = = 42 | | Operatot = = 47
124| | Operator = = 40 | | Operator = = 41 )
125return ture; //+ - * /运算符
126else
127return false;
128}
129
130//---------------------------------------------------
131// 判断运算符的优先权
132//----------------------------------------------------
133public int Priority (int operator)
134{
135//+ -* （运算符
136if ( operator = = 43 | | operator = = 45 | | operator = = 40 )
137return 1;
138else if (operator = = 42 | | operator = = 47 ) // * / 运算符
139return 2;
140else
141return 0;
142}
143}
嵌入式技术基础与实践_习题参考答案
单片机习题参考答案 第1章概述习题参考答案 1．嵌入式系统的基本含义是什么？为什么说单片机是典型的嵌入式系统？ 答：即MCU的含义是：在一块芯片上集成了中央处理单元（CPU）、存储器（RAM/ROM 等）、定时器/计数器及多种输入输出（I/O）接口的比较完整的数字处理系统。大部分嵌入式系统以MCU为核心进行设计。MCU从体系结构到指令系统都是按照嵌入式系统的应用特点专门设计的，它能很好地满足应用系统的嵌入、面向测控对象、现场可靠运行等方面的要求。因此以MCU为核心的系统是应用最广的嵌入式系统。 简述嵌入式系统的特点以及应用领域。 答：嵌入式系统属于计算机系统，但不单独以通用计算机的面目出现;嵌入式系统开发需要专用工具和特殊方法;使用MCU设计嵌入式系统，数据与程序空间采用不同存储介质;开发嵌入式系统涉及软件、硬件及应用领域的知识;嵌入式系统的其他特点,比如紧张的资源，较高稳定性要求，低功耗，低成本等。一般用于工业控制，智能家电，日常电子等领域。 3．比较MCU与CPU的区别与联系。 答：CPU是一个单独的PC处理器。而MCU，则有微处理器，存储器（RAM/ROM等）、定时器/计数器及多种输入输出（I/O）接口的比较完整的数字处理系统。所以可以这么说，MCU 是一个包含微处理器的嵌入式系统，而CPU紧紧是一个处理器而已。 4．举例说明嵌入式系统在日常生活中的应用。 答：日常数码产品：手机，MP3，U盘，相机等。 日常工业类：冰箱，空调，微波炉，汽车等。 5．C语言的那些特性使得它成为嵌入式系统中使用频率最高的高级语言。 答：相比底端汇编，更简单易学；与高级语言如（C++，C#，java等）相比，执行效率高，编译后的编码体积小，而且支持好的编译器还支持嵌入汇编代码；对位的操纵能力很强。6．阅读光盘中【第01章(概述)阅读资料】中的“嵌入式C语言工程简明规范”，用一页纸给出嵌入式C语言工程简明规范的要点。 答：此规范主要针对单片机编程语言和08编译器而言，包括命名、注释、编码规范性等内容。建议在一个工程或者一个项目中尽量遵循相同的代码规范，而不是说你只能拥有一个代码规范。 （1）命名规则：命名清晰明了，有明确含义，使用完整单词或约定俗成的缩写。通常，较短的单词可通过去掉元音字母形成缩写；较长的单词可取单词的头几个字母形成缩写。即"见名知意"；命名风格要自始至终保持一致；命名中若使用特殊约定或缩写，要有注释说明；为了代码复用，命名中应避免适用与具体项目相关的前缀；应使用英语命名。 （2）注释：注释基本原则就是有助于对程序的阅读理解，说明程序在"做什么"，解释代码的目的、功能和采用的方法。一般情况源程序有效注释量在30％左右。注释语言必须准确、易懂、简洁。边写代码边注释，修改代码同时修改相应的注释，不再有用的注释要删除。汇编和C中都用"//"，取消";" 不使用段注释" /* */ "（调试时可用）。 使用文件注释必须说明文件名、项目名称、函数功能、创建人、创建日期、版本信息等相关信息。修改文件代码时，应在文件注释中记录修改日期、修改人员，并简要说明此次修改的目的。所有修改记录必须保持完整。文件注释放在文件顶端，用"/*……*/"格式包含。
仓储部管理制度---全
**实业有限公司仓储部管理制度汇编 目录
第一章：仓库物资出入库管理制度 第一节：原料验收入库管理制度 第二节：仓库物资保管管理制度 第三节仓库物资出库管理制度 第二章仓库管理制度 第三章单据流通管理制度 第四章降等品、次品、废品保管制度 第五章仓库盘点制度 第一章仓库物资出入库管理制度 第一节原料验收入库管理制度
1．目的 通过制定原料入库管理制度，指导和规范仓库人员日常作业行为。 2．适用范围 本规定适应于江西井竹实业有限公司仓储部 3．职责 仓库管理员负责物料的收料、报检、入库、发料、退料、储存、防护等工作； 4．内容 4．1物资到公司后库管员依据合同计划或请购单项目结合供货商的送货清单所列的名称、数量进行核对、清点，经使用部门或请购人员及检验人员对质量检验合格后，方可入库； 4．2对入库物资核对、清点后，库管员及时填写入库单，库管员、财务各持一联做帐，采购人员持一联做请款报销凭证； 4．3 库管要严格把关，有以下情况时可拒绝验收或入库： 4.3.1 未经总经理或部门主管批准的采购； 4.3.2 与合同计划或请购单不相符的采购物资； 4.3.3 与要求不符合的采购物资； 4.3.4 检验不合格物资； 4.3.4 状态标示不清晰物资； 4.3.5 包装不规范、包装严重损坏物资； 5．物料入库及走单流程图：
第二节仓库物资保管管理制度 1、目的 通过制定仓库物资保管制度，指导和规范仓库人员日常作业行为。 2、适用范围 本规定适应于江西井竹实业有限公司仓储部 3、职责 保证库存物资的安全储存、防护； 4、内容 4.1物资入库后，需按不同类别、性能、特点和用途分类分区码放，做到“二齐、三清、四号定位”。 4.1.1二齐：物资摆放整齐、库容干净整齐。 4.1.2 三清：材料清、数量清、规格标识清。 4.1.3四号定位：按区、按排、按架、按位定位 4.2库管员对常用或每日有变动的物资要随时盘点，若发现误差须及时找出原因并更正 4.2.1库存信息及时呈报。须对数量、文字、表格仔细核对，确保报表数据的准确性和可靠性 4.2.2根据库存信息,及订单情况及时呈报生产常规物料的采购早请。 4.2.3建立的个人资产(工具)账将作为个人岗位调整或离职时，移交物品的一项重要内容，耐用管理品如有损坏，凡属产品本身质量问题的，办理以旧换新手续：属于个人使用不当等原因造成的损坏或丢失，由使用人进行赔偿。
arm堆栈操作(DOC)
arm堆栈操作 arm堆栈的组织结构是满栈降的形式，满栈即sp是要停留在最后一个进栈元素，降：就是堆栈的增长方向是从高地址向低地址发展。 arm对于堆栈的操作一般采用LDMFD （pop）和STMFD （push) 两个命令。 以前困惑的就是STMFD 命令对于操作数是按照什么顺序压栈的 比如：STMFD sp！{R0-R5，LR} 进栈顺序是： 高地址（1方式） LR R5 R4 ``````` R0 <-sp 低地址 还是： 高地址（2方式） R0
R1 ``` R5 LR <-sp 低地址 现在通过下表，可以轻松的解决这个问题：
按照图表，可知STMFD对应的是STMDB，根据arm指令手册，可知STMDB入栈顺序是（1方式） 而LDMFD对应的是LDMIA，这样这两个操作就可以成功配对： 以下是我在学习ARM指令中记录的关于堆栈方面的知识 1、寄存器R13 在ARM 指令中常用作堆栈指针 2、对于R13 寄存器来说，它对应6 个不同的物理寄存器，其中的一个是用户模式与系统模式共用，另外5个物理寄存器对应于其他5种不同的运行模式。采用以下的
记号来区分不同的物理寄存器： R13_
栈的表示及栈的应用
实验二：栈的表示及栈的应用 【实验目的】 （1） 掌握栈的顺序存储结构及其基本操作的实现。 （2） 掌握栈后进先出的特点，并利用其特性在解决实际问题中的应用。 （3） 掌握用递归算法来解决一些问题。 【实验内容】 1. 编写程序，对于输入的任意一个非负十进制整数，输出与其等值的八进制数（课本P48）。 2. 编写递归程序，实现以下函数的求解（课本P54）。 3. 编写程序，实现Hanoi 塔问题（课本P55-P58）。 【实验步骤】 1.打开VC++。 2.建立工程：点File->New ，选Project 标签，在列表中选Win32 Console Application ，再在右边的框里为工程起好名字，选好路径，点OK->finish 。至此工程建立完毕。 3.创建源文件或头文件：点File->New ，选File 标签，在列表里选C++ Source File 。给文件起好名字，选好路径，点OK 。至此一个源文件就被添加到了你刚创建的工程之中。 4．写好代码 5．编译－＞链接－＞调试 【主要代码】进制转换 #include
#define OVERFLOW -2 typedef int Status; typedef int SElemType; #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef struct { SElemType *base; SElemType *top; int stacksize; }SqStack; Status InitStack(SqStack &S){//构造一个空栈 S.base=(SElemType *)malloc (STACK_INIT_SIZE*sizeof(SElemType)); if (!S.base) exit (OVERFLOW);//存储分配失败 S.top= S.base; S.stacksize=STACK_INIT_SIZE; return OK; }//InitStack Status Push(SqStack &S, SElemType e){ //插入元素e为新的栈顶元素 if (S.top-S.base>=S.stacksize) { //栈满，追加存储空间 S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT) *sizeof(SElemType)); if (!S.base) exit(OVERFLOW);//存储分配失败 S.top=S.base+S.stacksize; S.stacksize+=STACKINCREMENT; } *S.top++=e; return OK; } //PUSH Status Pop(SqStack &S, SElemType &e) { //若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
孟祥莲嵌入式系统原理及应用教程部分习题答案
习题1 1. 嵌入式系统的概念的是什么？答：嵌入式系统是以应用为中心，以计算机技 术为基础，软、硬件可裁剪，适应应用系统对功能、可靠性、成本、体积、功耗等严格要求的专用计算机系统。（嵌入式系统是嵌入式到对象体系中的，用于执行独立功能的专用计算机系统。） 2. 嵌入式系统的特点是什么？ 答：系统内核小；专用性强；运行环境差异大；可靠性要求高；系统精简和高实时性操作系统；具有固化在非易失性存储器中的代码嵌入式系统开发和工作环境 4. 嵌入式系统的功能是什么？答：提供强大的网络服务小型化，低成本，低 功能；人性化的人机界面；完善的开发平台 5. 嵌入式系统的硬件平台由哪些部分组成？答：嵌入式系统的硬件是以嵌入式处理器为核心，由存储器I/O 单元电路，通信模块，外部设备必要的辅助接口组成的。 7. 嵌入式操作系统的主要特点是什么？答：体积小；实时性；特殊的开发调试环境。 8. 叙述嵌入式系统的分类。答：按嵌入式微处理器的位数分类可以分为4 位、 8 位、16 位、32 位和64 位等；按软件实时性需求分类可以分为非实时系统（如PDA）， 软实时系统（如消费类产品）和硬实时系统（如工业实时控制系统）按嵌入式系统的复杂程度分类可以分为小型嵌入式系统，中型嵌入式系统和复杂嵌入式系统。 习题2 处理器和工作状态有哪些？
答：ARM犬态：此时处理器执行32位的的字对齐的ARS旨令。 Thumb犬态：此时处理器执行16位的，半字对齐的Thumb旨令 2.叙述ARM9内部寄存器结构，并分别说明R13 R14 R15寄存器的 作用。 答：共有37个内部寄存器，被分为若干个组（BANK，这些寄存器包括31个通用寄存器，包括程序计数器（PC指针）6个状态寄存器。R13用作堆栈指针，R14称为子程序链接寄存器，R15用作程序计数器。处理器的工作模式有哪些？ 答：用户模式：ARM处理器正常的程序执行状态。 快速中断模式：用于高速数据传输或通道处理 外部中断模式：用于通用中断处理管理模式：操作系统使用的保护模式数据访问终止模式：当数据或指令预期终止时进入该模式，可用于虚拟存储器及存储保护 系统模式：运行具有特权的操作系统任务 未定义指令终止模式：当未定义的指令执行时进入该模式，可用 于支持硬件协处理器的软件仿真。 微处理器支持的数据类型有哪些？ 答：ARM微处理器中支持字节（8位）、半字（16位），字（32 位）
栈的基本操作与应用
实验报告 课程名称数据结构实验名称栈的基本操作与应用 姓名王灵慧专业班级软工18104 学号 201817040409 试验日期 2019-11-06试验地点E3-502指导老师邹汉斌成绩 一、实验目的 1．熟悉并能实现栈的定义和基本操作。 2．了解和掌握栈在递归和非递归算法的应用。 二、实验要求 1．进行栈的基本操作时要注意栈“后进先出”的特性。 2．编写完整程序完成下面的实验内容并上机运行。 3．整理并上交实验报告。 三、实验内容 1．编写程序任意输入栈长度和栈中的元素值，构造一个顺序栈，对其进行清空、销毁、入栈、出栈以及取栈顶元素操作。 2.已知函数t(n)=2*t(n/2)+n 其中t(0)=0，n为整数。编写程序实现： (1)计算t(n)的递归算法。 (2)分别用链式栈和顺序栈实现计算t(n)的非递归算法。 四、思考与提高 1．如果一个程序中要用到两个栈，为了不发生上溢错误，就必须给每个栈预先分配一个足够大的存储空间。若每个栈都预分配过大的存储空间，势必会造成系统空间紧张。如何解决这个问题？ 五、实验步骤（每个实验内容包含代码、输入、输出、错误分析）： 1、实验内容（1）： #include
嵌入式系统原理及应用题目要求+程序代码
《嵌入式系统原理及应用》作业题目 作业1 一、调试下面的程序，并回答问题。 .global _start .text _start: LDR SP, =src LDMFD SP!,{R0-R6} STMFD SP!,{R0-R6} LDMFD SP!,{R3} LDMFD SP!,{R4} LDMFD SP!,{R5} LDMFD SP!,{R6} LDMFD SP!,{R0} LDMFD SP!,{R1} LDMFD SP!,{R2} stop: b stop .ltorg src: .long 1,2,3,4,5,6,7 .end 问：该程序完成了什么功能？ 答： 该程序完成的功能：先把数据区堆栈中的1~7这七个数据送给R0~R0寄存器，然后又把寄存器列表中的R0~R7存入堆栈，然后又依次把堆栈中的1~7这七个数送给R3~R6,R0~R2,然后程序就结束了，在取数和存数的过程中。堆栈指针sp由0x0000变到0x8030再到0x804c，然后到0x8030，然后依次加4，最后到0x804c；程序计数器R15（PC）由0x8000地址依次加4 。 二、LDMFD,STMFD伪代码实现的原理。 答： 指令STMFD和LDMFD分析： 根据ATPCS规则，我们一般使用FD（Full Descending）类型的数据栈！所以经常使用的指令就有STMFD和LDMFD， 通过ARM对于栈操作和批量Load/Store指令寻址方式，可以知道指令STMFD和LDMFD 的地址计算方法：
STMFD指令的寻址方式为事后递减方式(DB) 而DB寻址方式实际存地址为： start_address = Rn - (Number_Of_Set_Bits_In(register_list)*4) end_address = Rn - 4 STM指令操作的伪代码： if ConditionPassed(cond) then address = start_address for i = 0 to 15 if register_list[i] == 1 Memory[address] = Ri address = address + 4 有上面两个伪代码可以得出STMFD SP！，{R0-R7，LR} 的伪代码如下：SP ＝SP －9×4； address =SP; for i = 0 to 7 Memory[address] = Ri; address= address + 4; Memory[address] = LR; LDMFD指令的寻址方式为事后递增方式(IA) IA存的实际地址的伪代码 start_address = Rn end_address = Rn + (Number_of_set_bits_in(register_list)*4) - 4 LDM指令操作的伪代码(未考虑PC寄存器)： if ConditionPassed(cond) then address = start_address for i = 0 to 15 if register_list[i] == 1 Ri ＝Memory[address,4] address = address + 4 所以LDMFD SP！，{R0-R7，PC}^ （；恢复现场，异常处理返回）伪代码是: address = SP; for i = 0 to 7 Ri = Memory[address ,4] address = address + 4; SP = address; 作业2 一、用移位操作完成（R0）*10运算。 参考程序： .text .global _start
公司质量管理制度文件汇编材料
公司质量管理制度文件 材料汇编 目录 序号标题页码 1、质量事故仲裁及责任追究管理办法 (2) 2 3 4 5 6 7 1. 量责任意识，规范其质量管理行为，特制定本制度。 2.事故分类 2.1重大质量事故 2.1.2出口水泥（熟料）不满足合同约定指标; f-CaO＞2.0%；抗压强度3天低于25.0MPa；28天低于53.0MPa；
2. 2 质量事故 f-CaO＞1.5%；抗压强度3天低于28.0MPa；28天低于55.0MPa； 3.事故确定程序 3.1内部客户投诉确定 内部客户投诉主要针对集团内部熟料基地向粉磨站销售商品熟料，因熟料质量不符合海螺标准要求，影响粉磨企业正常生产组织或产品质 凡时 kg 、 d.由品质部安排对买卖双方封存样进行检测，召集双方结合上述材料共同分析确定该批熟料实物质量。 a.如双方现场检测f-CaO超过合同指标(制样方法同仲裁检测)，卖方认同该检测结果，则判定投诉属实；如卖方对买方检测结果有异议，可以对其检测条件、方法进行验证或要求其检测自己带去的标准样品。 b.如双方现场检测不能达成一致意见，由品质部安排对双方共同封
存样品进行仲裁检测，以此结果为最终结果。负责仲裁的单位应认真检查仲裁样品的封存情况并做好记录，如仲裁需检测f-CaO，应对样品进行混匀取5.0kg不加石膏于小磨中粉磨20 min，倒出再次混匀缩分至30-50g用于检测f-CaO。 c.如检测强度，可按规定直接将仲裁样打小磨做试验或将预粉磨测f-CaO剩余样品加适量石膏再粉磨到规定比表面积做试验。 3.2 “海螺”水泥而导致质量投诉，或子公司处理后客户不满意引起的二次投诉，由公司品质部负责协调处理，在接到投诉后24小时内组织相关部室人员或发运子公司到现场处理。 3.3出口产品的投诉确定 国检检验，以国检检验结果为准。 3.4 内部抽查确认
孟祥莲--嵌入式系统原理及应用教程-部分习题答案20150618
孟祥莲--嵌入式系统原理及应用教程-部分习题答案20150618
习题1 1.嵌入式系统的概念的是什么？ 答：嵌入式系统是嵌入式到对象体系中的，用于执行独立功能的专用计算机系统。 2.嵌入式系统的特点是什么？ 答：系统内核小；专用性强；运行环境差异大；可靠性要求高；系统精简和高实时性操作系统；具有固化在非易失性存储器中的代码嵌入式系统开发和工作环境 4.嵌入式系统的功能是是什么？ 答：提供强大的网络服务小型化，低成本，低功能；人性化的人机界面；完善的开发平台 5.嵌入式系统的硬件平台由哪些部分组成？ 答：嵌入式系统的硬件是以嵌入式处理器为核心，由存储器I/O单元电路，通信模块，外部设备必要的辅助接口组成的。 7.嵌入式操作系统的主要特点是什么？ 答：体积小；实时性；特殊的开发调试环境。8.叙述嵌入式系统的分类。 答：按嵌入式微处理器的位数分类可以分为4位、8位、16位、32位和64位等；按软件实时性需求分类可以分为非实时系统（如PDA），软
实时系统（如消费类产品）和硬实时系统（如工业实时控制系统）；按嵌入式系统的复杂程度分类可以分为小型嵌入式系统，中型嵌入式系统和复杂嵌入式系统。 习题2 1.ARM9处理器和工作状态有哪些？ 答：ARM状态：此时处理器执行32位的的字对齐的ARM指令。 Thumb状态：此时处理器执行16位的，半字对齐的Thumb指令 2.叙述ARM9内部寄存器结构，并分别说明R13、R14、R15寄存器的作用。 答：共有37个内部寄存器，被分为若干个组（BANK），这些寄存器包括31个通用寄存器，包括程序计数器（PC指针）6个状态寄存器。R13用作堆栈指针，R14称为子程序链接寄存器，R15用作程序计数器。 4.ARM处理器的工作模式有哪些？ 答：用户模式：ARM处理器正常的程序执行状态。 快速中断模式：用于高速数据传输或通道处
仓储管理制度
仓储管理制度 第一章总则 第一条为确保仓储物资的规范有效管理，提高仓储工作效率，特制订本制度。 第二条本制度适用于集团供应系统所属仓库的管理。 第二章物资入库流程 第三条仓库保管员应在接到请购单位请购计划的当日完成审核提交工作，并根据采购计划，通过部门信息共享文件夹跟催临近采购到货期限而未到的物资，及时提醒各主办业务人员进行处理。大生产计划（五一、中秋国庆、元旦春节）应通过请购单位和采购中心召开过计划讨论会后汇总提交。 第四条物资验收与抽检要求 （一）物资到货接收时，仓库保管员必须要求供应商提供送货清单、该批物资的出厂检验报告，且进口物资必须有中文标识，材料不全的物资保管员应拒收。 （二）仓库保管员按照送货清单上的名称、规格、数量及物资的感官质量进行验收，感官质量不合要求的物资应予以拒收。 （三）对属标准件的物资，仓库保管员应按1%-5%的比例抽检，如发现有单个标准件数量不符合规定要求的，则此批物资均按少出部分的百分比进行扣减。 （四）对非标准件物资要求全部称量，数量出现短缺的，应要求供应商按2-5倍给予折扣处理。 第五条仓库保管员在物资验收无误后方可给供货方出具收货单或在客户送货单回执联签收确认。 第六条仓库保管员在验收物资前要检查计量器具，保证其准确性。物资验收必须严格遵循国家计量单位的规定，同一物资的计量单位必须统一，不得使用国家明令规定作废的计量单位（如斤、尺等）。 第七条感官质量不合要求、到货数量超计划10%以上的物资如需暂存，必须有部门领导签审同意后方可，并注明暂存期限；对暂存物资,仓库保管员不可出具任何单据。
第八条仓库保管应在当日内将需经品管部检验的到货物资送检并配合品管人员的抽检取样工作。 第九条缴库时，仓库保管员应对照缴库单核对如下内容：请购计划、收货记录、质检报告，核对无误后填写实收数量并对数量负全责。特殊情况参照如下要求： （一）对于需由对应部门验质的物资（工程、基建、汽配），缴库时应有该类物资的验质人员在缴库单的“验收人栏”签字后方可入账； （二）对于无需检验部门验收的物资，仓库保管员核对原请购单对到货物资的品牌、规格、材质或样品等要求后，由对应的业务员办理缴库； （三）对某些大型设备、机械的缴库，必须由使用部门按照合同签订的试用期限进行试用后，由试用部门或工程部出具《设备验收记录表》，并经采购员或相关验质人员三方到场后办理缴库； （四）对未经保管验收实物就直接被使用部门使用的物资，必须凭使用部门第一负责人签字的出库单缴库。 第三章物资出库流程 第十条物资出库必需凭合格生效的出库单方可办理，出库单签审应由使用部门助理级以上人员或其指定代理人签审。 第十一条所有领用出库的物资必须为检验合格、让步接收、紧急放行范围内的物资，禁止发放处在待检、在检、不合格、过保质期状态下的物资。 第十二条对属让步接受或紧急放行的物资，出库时保管员必须在出库单备注栏上注明，以提醒领用部门在使用过程中随时关注质量情况。检验合格物资在出库单上必须标注该批物资的质检报告号。 第十三条物资的调拨出库，参见《物资调拨制度》中相关出库要求执行。 第十四条所有物资出库都必须遵循先进先出的出库原则，对未遵循此原则而导致库存物资超期造成变质的，应对保管人员全额索赔。 第十五条新品商标、包材、辅料、季节性促销用品等物资，请购单位须一次性全部出库。销售物资出库时应凭销售专用单、财务收据并经部门负责人签审后方可发货。 第十六条对大型设备、机械类等贵重物资的出库，如有质保书、说明书等，还须在出库单备注栏注明“质保书、说明书等随物件一并出库”字样。 第十七条亚硝、氢氧化钠等危险品出库时，应严格执行《有毒有害及危险品出库管理规定》，必须有完整的《有毒化合物领用发放记录》。
嵌入式原理与应用复习题
一.单项选择题 1. 下面哪项为错误的说法（Ａ） A. 冯·诺依曼结构共用数据存储空间和程序存储空间，不共享存储器总线 B. 哈佛结构有分离的数据和程序空间及分离的访问总线 C. 哈佛结构在指令执行时，取址和取数可以进行并行操作 D. 哈佛结构指令执行时效率更高 2. 下列关于/etc/fstab文件描述，正确的是（Ｄ） A. fstab文件只能描述属于linux的文件系统 B. CD_ROM和软盘必须是自动加载的 C. fstab文件中描述的文件系统不能被卸载 D. 启动时按fstab文件描述内容加载文件系统 3. ARM9和ARM7的重要区别是（Ａ） A . ARM9带有MMU功能 B . ARM9支持Thumb指令集 C . ARM9带有Cache功能 D . ARM9是哈佛结构 4. 如果数据的存储格式是大端模式，32bit宽的数0x在大端模式下的CPU内存中 的存放（假设从地址0x4000开始）。内存地址为0x4001的内容是（Ａ） 5. 文件exer1的访问权限为rw-r--r--，现要增加所有用户的执行权限和同组用户 的写权限，下列命令正确的是（Ａ） a+x g+w e x e r1765e x e r 1 o+x e x e r1g+w e x e r1 6. NAND FLASH和NOR FLASH的区别正确的是（Ｄ） A. NOR的读速度比NAND稍慢一些 的擦除速度远比NOR的慢 的写入速度比NOR慢很多 D.大多数写入操作需要先进行擦除操作。 7. gcc使用下列哪个选项可以查看编译的详细过程（Ｂ） A. -o B. -v D. -g 8. Boot Loader 的stage2通常使用C语言实现，以完成复杂的功能，并增加可读 性和可移植性，以下哪一步骤属于stage2的内容（Ｄ） A.为加载Boot Loader 的stage2 准备RAM 空间 B.设置好堆栈 C.硬件设备初始化 D.将kernel 映像和根文件系统映像从flash 上读到RAM 空间中 9. 怎样新建一个新文件：（Ａ） 10. 在vi编辑器的命令模式中，删除一行的命令是：（Ｂ）
项目工程材料管理制度汇编
项目工程材料管理制度 一、项目工称材料管理流程图： （1） （2） （3） （4） （5） （6） （7） （8） （9） （10） （11） （12） （13） 二、材料预算及供应计划:
1、施工员应熟练掌握国家施工规范和工程质量验收标准,在工序式 分项工程施工前编制科学先进的施工工艺式施工方案,在确保 工程质量和使用功能、安全性能的前提下,节约原材料。 2、项目部主任工程师审批施工方案的科学性或施工工艺的先进 性。 3、预算员按照审批后的施工方案作工序或分项工程的施工预算， 计算出工程质量并提供材料用量及用料分析,作为材料供应的 依据。 4、公司经营科认真审核施工预算，签字后交项目部。 5、设计变更应及时由有关人员办理变更手续,按以上程序作出方 案的相应调整和材料增减的申报和审批。 6、按照经营科审批后的材料预算用量,项目部根据工程进度等实 际情况编写“材料供应计划”。其中必须写清所需材料型号、 数量、密量标准、进场时间等内容,经项目经理审批后,上报公 司材料设备科采购。 三.材料采购 1、材料设备科按照审批后的材料供应计划综合库存和现场的实际 情况,按时保质保量供货。同时向库管员提供相应的合格证或产品材质证明资料。 2、材料设备科对供货商(大中型材料及设备)要建立供货档案,对其 资质、供货业绩、信誉度要进行考核考评,并签定供货合同。 供货合同一式三联,一联送财务科备案，二联留材料设备科,三
联交供货商。 3、采购员应及时向供货单位索取正式发票,在材料入库时由库管 员签字后，一联交财务科，二联交材料会计，三联交库管员。 库管员未签字的发票不得报账。 4、材料入库时,库管员应严格验收材料的质量和数量,签写“材料 入库收料单”三联单,其中一联单与正式发票的一联单一起交 财务报帐，二联单交材料会计计帐(并附上材料供应计划)，三 联单库管员保存,作为记帐和入库实物的凭证。库管员的出入 库单据及库存实物应每月盘存且必须保持平衡。 5、材料会计分项目部建立供货和出库物资台帐.随时计算供应量 与计划总量的差额,及库存物资数量，确保不超计划供应不使 库房物资积压、呆滞。每月监督库管员作一次库房盘点,当月 25日前作出各库房的平衡帐,交公司材料设备科及公司主管领 导,作为材料管理及决策的依据。小型材料须每周作一次盘 存，作为月盘的基础，做到“周清月结”。 四、材料保管及发放 (一)施工现场仓库管理制度 仓库是直接为施工生产服务的部门,仓库管理是材料供应工作的重要组织部分,承担着工程用材料的验收、保管、发放和合理使用权用的任务。仓库管理必须按以下规定工作： 1、仓库物资码放科学化。按物资分类的不同要求合理布局,整齐统 一,充分利用空间,采用“五五成行”或“五十成行”,“层层
详解堆栈的几种实现方法
详解堆栈的几种实现方法 基本的抽象数据类型（ADT）是编写C程序必要的过程，这类ADT有链表、堆栈、队列和树等，本文主要讲解下堆栈的几种实现方法以及他们的优缺点。 堆栈（stack）的显著特点是后进先出（Last-In First-Out, LIFO），其实现的方法有三种可选方案：静态数组、动态分配的数组、动态分配的链式结构。 静态数组：特点是要求结构的长度固定，而且长度在编译时候就得确定。其优点是结构简单，实现起来方便而不容易出错。而缺点就是不够灵活以及固定长度不容易控制，适用于知道明确长度的场合。 动态数组：特点是长度可以在运行时候才确定以及可以更改原来数组的长度。优点是灵活，缺点是由此会增加程序的复杂性。 链式结构：特点是无长度上线，需要的时候再申请分配内存空间，可最大程度上实现灵活性。缺点是链式结构的链接字段需要消耗一定的内存，在链式结构中访问一个特定元素的效率不如数组。 首先先确定一个堆栈接口的头文件，里面包含了各个方案下的函数原型，放在一起是为了实现程序的模块化以及便于修改。然后再接着分别介绍各个方案的具体实施方法。 堆栈接口stack.h文件代码： [cpp] view plain copy 1 /*** 堆栈模块的接口 stack.h #include
公司仓储管理制度汇编
仓储管理制度 一、公司仓库规划管理制度 第一条库位规划 物料管理室应依成品缴出库情况、包装、方式等规划所需库位及其面积，以使库位空间有效利用。 第二条库位配置 库位配置原则应依下列规定： 1．配合仓库设备（例如油压车、手推车、消防设施、通风设备、电源等）及所使用的储运工具规划运输通道。 2．依销售类别、产品类别分区存放，同类产品中计划产品与订制产品应分区存放，以利管理。 3．收发频繁的成品应配置于进出便捷的库位。 4．将各项成品依品名、规格、批号划定库位，标明于“库位配置图”上，并随时显示库存动态。 第三条成品堆放 物料管理室应会同质量管理室的质量管理人员，依成品包装形态及质量要求设定成品堆放方式及堆积层数，以避免成品受挤压而影响质量。 第四条库位标示
1．库位编号依下列原则办理并于适当位置作明显标示 （1）层次类别依A、B、C顺序逐层编订，没有时填“○”。 （2）库位流水编号。 （3）通道类别，依A、B、C顺序编订。 （4）仓库类别，依A、B、C顺序编订。 2．计划产品应于每一库位设置标示牌，标示其品名、规格及单位包装量。 3．物料管理室依库位配置情况绘制“库位标示图”悬挂于仓库明显处。 第五条库位管理 1．物料管理科收发料经办人员应掌握各库位、各产品规格的进出动态，并依先进先出原则指定收货及发货单位。 2．计划产品每种规格原则上应配置两个以上小库位，以备轮流交替使用，以达先进先出的要求。 二、库存量管理工作细则 第一条预估月用量设（修）定 1.用量稳定的材料由主管人员依去年的平均月用量，并参酌今年营业的销售目标与生产计划，若产销计划有重大变化（如开发或取消某一产品的生产扩建增产计划等）应修订月用量。 2．季节性与特殊性材料由生产管理人员于每年3、6、9、12月的25日以前依，前三个月及去年同期各月份的预计销售量，再乘以各产品的单位用量，而设定预估月用量。 第二条请购点设定 1．请购点——采购作业期间的需求量加上安全存量。 2．采购作业期间的需求量——采购作业期限乘以预估月用量
(完整版)嵌入式系统原理及应用复习知识点总结
第一章 1、嵌入式系统的应用范围：军事国防、消费电子、信息家电、网络通信、工业控制。 2、嵌入式系统定义：嵌入式系统是以应用为中心，以计算机技术为基础，软件与硬件可裁剪，适应应用系统对功能、可靠性、成本、体积、功耗严格要求的专用计算机系统。（嵌入式的三要素：嵌入型、专用性与计算机系统）。 3、嵌入式系统的特点：1)专用性强；2）实时约束；3）RTOS；4）高可靠性；5）低功耗；6）专用的开发工具和开发环境；7）系统精简； 4、嵌入式系统的组成： （1）处理器：MCU、MPU、DSP、SOC； （2）外围接口及设备：存储器、通信接口、I/O接口、输入输出设备、电源等；（3）嵌入式操作系统：windows CE、UCLinux、Vxworks、UC/OS; （4）应用软件：Bootloader 5、嵌入式系统的硬件：嵌入式微处理器（MCU、MPU、DSP、SOC），外围电路，外部设备； 嵌入式系统的软件：无操作系统（NOSES），小型操作系统软件（SOSES），大型操作系统软件（LOSES）注：ARM处理器三大部件：ALU、控制器、寄存器。 6、嵌入式处理器特点：（1）实时多任务；（2）结构可扩展；（3）很强的存储区保护功能；（4）低功耗； 7、DSP处理器两种工作方式：（1）经过单片机的DSP可单独构成处理器；（2）作为协处理器，具有单片机功能和数字处理功能； 第二章 1、IP核分类：软核、固核、硬核； 2、ARM处理器系列：（1）ARM7系列（三级流水，thumb指令集，ARM7TDMI）; (2)ARM9系列（DSP处理能力，ARM920T）（3）ARM/OE（增强DSP）（4）SecurCone 系列（提供解密安全方案）；（5）StrongARM系列（Zntle产权）；（6）XScale系列（Intel产权）；（7）Cortex系列（A：性能密集型；R：要求实时性；M：要求低成本） 3、ARM系列的变量后缀：（1）T：thumb指令集；（2）D：JTAG调试器；（3）快
发电厂仓库管理制度汇编
发电厂仓库治理制度 1.范围 本标准会顶了进厂我izide入库、贮存、出库、退料治理、料帐治理、安全治理、废料治理、物资分类、编码治理等相关内容。 本标准适用于本厂日常维修、维护、技改、大小修及其他非生产性（行政性）物资治理。 2.规范性使用文件 下列文件中的条款通过本标准的应用而常委标准的条款。凡是注日期的引用文件，其随后所有的修改单（不包括勘误的内容）或修订版均不适用于本标准，然而，鼓舞依照本标准达成协议的各方研究是否可使用这些文件的最新版分。凡是不住日期的引用文件，其最新版本适用于本标准。 电安生[1994]227号文电业生产安全规程制度（热力和机械
部分） DL408-91电业安全工作规程（发电厂和变电所电气部分） [80]技字第205号文电力工业技术治理法规 3.术语和定义 下列术语和定义适用于本标准。 3.1 入库：物资接收、验收和进账的过程。 3.2 出库：物资发放和销账的过程。 3.3 入库验证：依照物资的采购文件要求，对到物资资的名称、规格、型号、数量、包装标记、生产厂家及外观、合格证等按规定的要求进行验证。 3.4 质量验证：依照采购物资的特性和有关部颁或行业标准、规程，对到物资资进行检验和试验，以保证满足规定的要求。 3.5 战略物资：对机组出力及安全经济运行有直接重大阻碍的物资和设备。 3.6 呆滞物资：原设备已更换或改造，经专业确认不再使用的库存物资。 4.职责 4.1 设备治理部策划分部负责全厂物资的入库、贮存、出库以及上述过程的标识操纵及实施、库存定额的提出及评审、定
额内物资的自动补仓、废品废料处理等工作、 4.2 设备治理部策划分部负责到物资资的入库验证，同时负责保管未出库物资的讲明书、图纸、合格证等原始凭证、 4.3 各部门负责对本部门所提出采购要求的物资的质量验证及对应物资在仓库存放期间的专门保养工作。 4.4 生产经营部技术分部负责战略物资和常规物资库存定额的评审阻止，必要时参与战略物资的品质验证。 4.5 运行部化学自班负责到货油品的取样、品质验证。 5.治理内容与方法 5.1 物资入库 5.1.1 物资入库的差不多流程如图1： 图1 物资入库流程图 5.1.2 物资进厂后，由仓库主任依照部门内部分工原则，安排仓管员开始物资验证。 5.1.3 所有进厂物资必须通过验证。物资验证包括入库验
仓储管理在线测试答案
第一章在线测试 1. ( )就是运用现代化的经济技术方法对仓库和仓库中储存的物资进行管理。仓库管理 2. 正确计划、安排仓库中各种功能区的位置，正确安排收货区、存货区、拣货区等功能区的布置，这是仓库作业过程的( ) 。空间组织 3. 在仓储作业中减少不必要的停顿或等待，反应了仓储组织的哪项原则？连续性原则 4. 仓储作业组织的目标可以概括成。“快进、快出、高效、保质、低成本” 5. 仓储技术作业过程主要由入库、( ) 和出库三个阶段组成。保管 6. 为了提高仓库内部作业效率，实现仓储环节与其他环节的密切配合，同时与国际接轨，我国仓储业应实现( ) 。标准化 7. 我国商业仓库的最初形式是()邸店 8. 仓储组织的目标就是实现仓储活动的“快进、快出、多仓储、保管好、费用省”。错误 9. 仓储活动的产品生产过程和消费过程同时进行，不能储存也不能积累。正确 10. 仓储产业化是指仓储企业可以脱离保管业务单纯地进行产品的生产加工。错误 11. 正是因为有了产品剩余，需要将剩余产品收存，所以形成了仓储。正确 12. 仓储作业量的不均衡性主
要与货物到发的( ) 和( ) 有关。数量 多少，时间间隔的长短13.仓储作业的非连续性主要和（）与（）有 关。作业场地的空闲程度，人员和设备的繁忙程度 14?仓储产业化是指仓储企业有条件利用自身优势发展（）业务。流通加工 15. 在社会主义阶段，我国对旧中国接管改造的仓库实行了（）与（）相结合的体制。集中管理分散管理 16?人类社会自从有了（），就产生了储存。剩余物品 17. 仓储活动的意义之一是解决了商品生产和消费在（）、 （）和（）上的矛盾，从而使社会再生产过程得以顺利进行。空间时间方式 18?仓储技术作业过程被划分为（）、（）和（）三个阶段。入 库保管出库 19?目前，我国仓储业正朝着、、和的“四化”目标发展。社会化产业化标准化现代化20.仓储管理的内容包括、、、和其他内容，如安全管理.仓库的选址与布置，机械设备的选择与配置，仓库的业务管理，仓库的库存管理 21.仓储活动的生产性主要体现在、和三方面。是社 会再生产过程不可缺少的一环，具有生产三要素，某些环节已构成生产过程的一部分
堆栈的使用方法2
堆栈的使用方法 学院：教育信息与技术学院专业：信息工程班级：0802 姓名：江伟学号：2008116020220 一：实验任务 掌握堆栈的使用方法 二：实验工具 计算机、DSP 实验箱。 三：实验内容 1、用仿真器将计算机与DSP 实验箱连接好，并依次打开实验箱电源、仿真器电源，然后运行CCS 软件。 2、新建一个项目：点击Project－New，将项目命名为example3，并将项目保存在自己定义的文件夹下，注意文件夹一定要用英文名，不要将文件夹取名为中文名，因为CCS 软件不能识别以中文命名的文件夹。 3、新建一个源文件：点击File－New－Source File 可以打开一个文本编辑窗口，点击保存按键，保存在和项目相同的一个文件夹下面(example3)，保存类型选择*.ASM（如果源文件是C 语言编写的，保存类型选择*.C,本实验中的例程是使用汇编语言编写的,所以选择*.ASM 为保存类型），我们在这里将保存名字命名为example3.asm 。 4、在项目中添加源文件：在新建了一个源文件以后，要想使用CCS 编译器对该源文件进行编译还需要将源文件添加到项目中去。添加方法是在工程管理器中右键单击example3.pjt，在弹出的菜单中选择Add Files，然后将刚才建立的example3.asm 文件添加到该项目中去。 5、编写源程序： 在工程管理器中双击example3.asm ，将出现文本编辑窗口，在该文本编辑窗口中输入如下内容： .title "example3.asm" .mmregs size .set 100 stack .usect "STK",size ;堆栈的设置 .bss length,10H .def _c_int00;start .text _c_int00: B start; start: STM #0,SWWSR ;插入0 个等待状态 STM #stack+size,SP ;设置堆栈的指针 LD #-8531,A STM #size,AR1 MVMM SP,AR7 loop: STL A,*AR7- BANZ loop,*AR1- .end 6、编写链接配置文件： 参照实验一，需要更改的地方如下：