单片机中用C语言精确开平方及附加正弦函数表
在单片机中,通常我们需要算一个数的开方,但如果直接用
////////////输入整数////////////
///////////输出浮点型////////////////
//////////精确到8位小数///////////
#include
#define uint unsigned int
float sqre(int a);
main()
{
int i;
while(1)
{
printf("please input number:");
scanf("%d",&i); /*输入要开方的数*/
printf("i=%d\n",i);
printf("squr=%f\n",sqre(i)); /*被开方数大等于0时输出实数*/ }
}
float sqre(int a)
{
int i;
float b,c;
for(i=0;;i++)
{
if((a>i* i)&&(a<=(1+i)*(1+i)))
{
b=(float)(i+(1+i))/2;
break;
}
}
for(i=0;i<3;i++)
{
c=b+(a/b-b)/2;
b=c;
}
return b;
}
/*////////自己编写的,一起学习/////////*/
0.0{0.0000} 0.1{0.0017} 0.2{0.0035} 0.3{0.0052} 0.4{0.0070} 0.5{0.0087} 0.6{0.0105} 0.7{0.0122} 0.8{0.0140}
0.9{0.0157}
1.0{0.0175} 1.1{0.0192} 1.2{0.0209} 1.3{0.0227} 1.4{0.0244} 1.5{0.0262} 1.6{0.0279} 1.7{0.0297} 1.8{0.0314}
1.9{0.0332}
2.0{0.0349} 2.1{0.0366} 2.2{0.0384} 2.3{0.0401} 2.4{0.0419} 2.5{0.0436} 2.6{0.0454} 2.7{0.0471} 2.8{0.0488}
2.9{0.0506}
3.0{0.0523} 3.1{0.0541} 3.2{0.0558} 3.3{0.0576} 3.4{0.0593} 3.5{0.0610} 3.6{0.0628} 3.7{0.0645} 3.8{0.0663} 3.9{0.0680}
4.0{0.0698}
4.1{0.0715}
4.2{0.0732}
4.3{0.0750}
4.4{0.0767}
4.5{0.0785}
4.6{0.0802}
4.7{0.0819}
4.8{0.0837}
4.9{0.0854}
5.0{0.0872}
5.1{0.0889}
5.2{0.0906}
5.3{0.0924}
5.4{0.0941}
5.5{0.0958}
5.6{0.0976}
5.7{0.0993}
5.8{0.1011}
5.9{0.1028}
6.0{0.1045}
6.1{0.1063}
6.2{0.1080}
6.3{0.1097}
6.4{0.1115}
6.5{0.1132}
6.6{0.1149}
6.7{0.1167}
6.8{0.1184}
6.9{0.1201}
7.0{0.1219}
7.1{0.1236}
7.2{0.1253}
7.3{0.1271}
7.4{0.1288}
7.5{0.1305}
7.6{0.1323}
7.7{0.1340}
7.8{0.1357}
7.9{0.1374}
8.0{0.1392}
8.1{0.1409}
8.2{0.1426}
8.3{0.1444}
8.4{0.1461}
8.5{0.1478}
8.6{0.1495}
8.7{0.1513}
8.8{0.1530}
8.9{0.1547}
9.0{0.1564}
9.1{0.1582}
9.2{0.1599}
9.3{0.1616}
9.4{0.1633}
9.5{0.1650}
9.6{0.1668}
9.7{0.1685}
9.8{0.1702}
9.9{0.1719}
10.0{0.1736}
10.1{0.1754}
10.2{0.1771}
10.3{0.1788}
10.4{0.1805}
10.5{0.1822}
10.6{0.1840}
10.7{0.1857}
10.8{0.1874}
10.9{0.1891}
11.0{0.1908}
11.1{0.1925}
11.2{0.1942}
11.3{0.1959}
11.4{0.1977}
11.5{0.1994}
11.6{0.2011}
11.7{0.2028}
11.8{0.2045}
11.9{0.2062}
12.0{0.2079}
12.1{0.2096}
12.2{0.2113}
12.3{0.2130}
12.4{0.2147}
12.5{0.2164}
12.6{0.2181}
12.7{0.2198}
12.8{0.2215}
12.9{0.2233}
13.0{0.2250}
13.1{0.2267}
13.2{0.2284}
13.3{0.2300}
13.4{0.2317}
13.5{0.2334}
13.6{0.2351}
13.7{0.2368}
13.8{0.2385}
13.9{0.2402}
14.0{0.2419}
14.1{0.2436}
14.2{0.2453}
14.3{0.2470}
14.4{0.2487}
14.5{0.2504}
14.6{0.2521}
14.7{0.2538}
14.8{0.2554}
14.9{0.2571}
15.0{0.2588}
15.1{0.2605}
15.2{0.2622}
15.3{0.2639}
15.4{0.2656}
15.5{0.2672}
15.6{0.2689}
15.7{0.2706}
15.8{0.2723}
15.9{0.2740}
16.0{0.2756}
16.1{0.2773}
16.2{0.2790}
16.3{0.2807}
16.4{0.2823}
16.5{0.2840}
16.6{0.2857}
16.7{0.2874}
16.8{0.2890}
16.9{0.2907}
17.0{0.2924}
17.1{0.2940}
17.2{0.2957}
17.3{0.2974}
17.4{0.2990}
17.5{0.3007}
17.6{0.3024}
17.7{0.3040}
17.8{0.3057}
17.9{0.3074}
18.0{0.3090}
18.1{0.3107}
18.2{0.3123}
18.3{0.3140}
18.4{0.3156}
18.5{0.3173}
18.6{0.3190}
18.7{0.3206}
18.8{0.3223}
18.9{0.3239}
19.0{0.3256}
19.1{0.3272}
19.2{0.3289}
19.3{0.3305}
19.4{0.3322}
19.5{0.3338}
19.6{0.3355}
19.7{0.3371}
19.8{0.3387}
19.9{0.3404}
20.0{0.3420} 20.1{0.3437} 20.2{0.3453} 20.3{0.3469} 20.4{0.3486} 20.5{0.3502} 20.6{0.3518} 20.7{0.3535} 20.8{0.3551}
20.9{0.3567}
21.0{0.3584} 21.1{0.3600} 21.2{0.3616} 21.3{0.3633} 21.4{0.3649} 21.5{0.3665} 21.6{0.3681} 21.7{0.3697} 21.8{0.3714}
21.9{0.3730}
22.0{0.3746} 22.1{0.3762} 22.2{0.3778} 22.3{0.3795} 22.4{0.3811} 22.5{0.3827} 22.6{0.3843} 22.7{0.3859} 22.8{0.3875}
22.9{0.3891}
23.0{0.3907} 23.1{0.3923} 23.2{0.3939} 23.3{0.3955} 23.4{0.3971} 23.5{0.3987} 23.6{0.4003} 23.7{0.4019} 23.8{0.4035}
23.9{0.4051}
24.0{0.4067} 24.1{0.4083} 24.2{0.4099} 24.3{0.4115} 24.4{0.4131}
24.5{0.4147}
24.6{0.4163}
24.7{0.4179}
24.8{0.4195}
24.9{0.4210}
25.0{0.4226}
25.1{0.4242}
25.2{0.4258}
25.3{0.4274}
25.4{0.4289}
25.5{0.4305}
25.6{0.4321}
25.7{0.4337}
25.8{0.4352}
25.9{0.4368}
26.0{0.4384}
26.1{0.4399}
26.2{0.4415}
26.3{0.4431}
26.4{0.4446}
26.5{0.4462}
26.6{0.4478}
26.7{0.4493}
26.8{0.4509}
26.9{0.4524}
27.0{0.4540}
27.1{0.4555}
27.2{0.4571}
27.3{0.4586}
27.4{0.4602}
27.5{0.4617}
27.6{0.4633}
27.7{0.4648}
27.8{0.4664}
27.9{0.4679}
28.0{0.4695}
28.1{0.4710}
28.2{0.4726}
28.3{0.4741}
28.4{0.4756}
28.5{0.4772}
28.6{0.4787}
28.7{0.4802}
28.8{0.4818}
28.9{0.4833}
29.0{0.4848}
29.1{0.4863}
29.2{0.4879}
29.3{0.4894}
29.4{0.4909}
29.5{0.4924}
29.6{0.4939}
29.7{0.4955}
29.8{0.4970}
29.9{0.4985}
30.0{0.5000}
30.1{0.5015}
30.2{0.5030}
30.3{0.5045}
30.4{0.5060}
30.5{0.5075}
30.6{0.5090}
30.7{0.5105}
30.8{0.5120}
30.9{0.5135}
31.0{0.5150}
31.1{0.5165}
31.2{0.5180}
31.3{0.5195}
31.4{0.5210}
31.5{0.5225}
31.6{0.5240}
31.7{0.5255}
31.8{0.5270}
31.9{0.5284}
32.0{0.5299}
32.1{0.5314}
32.2{0.5329}
32.3{0.5344}
32.4{0.5358}
32.5{0.5373}
32.6{0.5388}
32.7{0.5402}
32.8{0.5417}
32.9{0.5432}
33.0{0.5446}
33.1{0.5461}
33.2{0.5476}
33.3{0.5490}
33.4{0.5505}
33.5{0.5519}
33.6{0.5534}
33.7{0.5548}
33.8{0.5563}
33.9{0.5577}
34.0{0.5592}
34.1{0.5606}
34.2{0.5621}
34.3{0.5635}
34.4{0.5650}
34.5{0.5664}
34.6{0.5678}
34.7{0.5693}
34.8{0.5707}
34.9{0.5721}
35.0{0.5736}
35.1{0.5750}
35.2{0.5764}
35.3{0.5779}
35.4{0.5793}
35.5{0.5807}
35.6{0.5821}
35.7{0.5835}
35.8{0.5850}
35.9{0.5864}
36.0{0.5878}
36.1{0.5892}
36.2{0.5906}
36.3{0.5920}
36.4{0.5934}
36.5{0.5948}
36.6{0.5962}
36.7{0.5976}
36.8{0.5990}
36.9{0.6004}
37.0{0.6018}
37.1{0.6032}
37.2{0.6046}
37.3{0.6060}
37.4{0.6074}
37.5{0.6088}
37.6{0.6101}
37.7{0.6115}
37.8{0.6129}
37.9{0.6143}
38.0{0.6157}
38.1{0.6170}
38.2{0.6184}
38.3{0.6198}
38.4{0.6211}
38.5{0.6225}
38.6{0.6239}
38.7{0.6252}
38.8{0.6266}
38.9{0.6280}
39.0{0.6293}
39.1{0.6307}
39.2{0.6320}
39.3{0.6334}
39.4{0.6347}
39.5{0.6361}
39.6{0.6374}
39.7{0.6388}
39.8{0.6401}
39.9{0.6414}
40.0{0.6428}
40.1{0.6441}
40.2{0.6455}
40.3{0.6468}
40.4{0.6481}
40.5{0.6494}
40.6{0.6508}
40.7{0.6521}
40.8{0.6534}
40.9{0.6547}
41.0{0.6561}
41.1{0.6574}
41.2{0.6587}
41.3{0.6600}
41.4{0.6613}
41.5{0.6626}
41.6{0.6639}
41.7{0.6652}
41.8{0.6665}
41.9{0.6678}
42.0{0.6691} 42.1{0.6704} 42.2{0.6717} 42.3{0.6730} 42.4{0.6743} 42.5{0.6756} 42.6{0.6769} 42.7{0.6782} 42.8{0.6794}
42.9{0.6807}
43.0{0.6820} 43.1{0.6833} 43.2{0.6845} 43.3{0.6858} 43.4{0.6871} 43.5{0.6884} 43.6{0.6896} 43.7{0.6909} 43.8{0.6921}
43.9{0.6934}
44.0{0.6947} 44.1{0.6959} 44.2{0.6972} 44.3{0.6984} 44.4{0.6997} 44.5{0.7009} 44.6{0.7022} 44.7{0.7034} 44.8{0.7046}
44.9{0.7059}
45.0{0.7071} 45.1{0.7083} 45.2{0.7096} 45.3{0.7108} 45.4{0.7120} 45.5{0.7133} 45.6{0.7145} 45.7{0.7157} 45.8{0.7169}
45.9{0.7181}
46.0{0.7193} 46.1{0.7206} 46.2{0.7218} 46.3{0.7230} 46.4{0.7242}
46.5{0.7254}
46.6{0.7266}
46.7{0.7278}
46.8{0.7290}
46.9{0.7302}
47.0{0.7314}
47.1{0.7325}
47.2{0.7337}
47.3{0.7349}
47.4{0.7361}
47.5{0.7373}
47.6{0.7385}
47.7{0.7396}
47.8{0.7408}
47.9{0.7420}
48.0{0.7431}
48.1{0.7443}
48.2{0.7455}
48.3{0.7466}
48.4{0.7478}
48.5{0.7490}
48.6{0.7501}
48.7{0.7513}
48.8{0.7524}
48.9{0.7536}
49.0{0.7547}
49.1{0.7559}
49.2{0.7570}
49.3{0.7581}
49.4{0.7593}
49.5{0.7604}
49.6{0.7615}
49.7{0.7627}
49.8{0.7638}
49.9{0.7649}
50.0{0.7660}
50.1{0.7672}
50.2{0.7683}
50.3{0.7694}
50.4{0.7705}
50.5{0.7716}
50.6{0.7727}
50.7{0.7738}
50.8{0.7749}
50.9{0.7760}
51.0{0.7771}
51.1{0.7782}
51.2{0.7793}
51.3{0.7804}
51.4{0.7815}
51.5{0.7826}
51.6{0.7837}
51.7{0.7848}
51.8{0.7859}
51.9{0.7869}
52.0{0.7880}
52.1{0.7891}
52.2{0.7902}
52.3{0.7912}
52.4{0.7923}
52.5{0.7934}
52.6{0.7944}
52.7{0.7955}
52.8{0.7965}
52.9{0.7976}
53.0{0.7986}
53.1{0.7997}
53.2{0.8007}
53.3{0.8018}
53.4{0.8028}
53.5{0.8039}
53.6{0.8049}
53.7{0.8059}
53.8{0.8070}
53.9{0.8080}
54.0{0.8090}
54.1{0.8100}
54.2{0.8111}
54.3{0.8121}
54.4{0.8131}
54.5{0.8141}
54.6{0.8151}
54.7{0.8161}
54.8{0.8171}
54.9{0.8181}
55.0{0.8192}
55.1{0.8202}
55.2{0.8211}
55.3{0.8221}
55.4{0.8231}
55.5{0.8241}
55.6{0.8251}
55.7{0.8261}
55.8{0.8271}
55.9{0.8281}
56.0{0.8290}
56.1{0.8300}
56.2{0.8310}
56.3{0.8320}
56.4{0.8329}
56.5{0.8339}
56.6{0.8348}
56.7{0.8358}
56.8{0.8368}
56.9{0.8377}
57.0{0.8387}
57.1{0.8396}
57.2{0.8406}
57.3{0.8415}
57.4{0.8425}
57.5{0.8434}
57.6{0.8443}
57.7{0.8453}
57.8{0.8462}
57.9{0.8471}
58.0{0.8480}
58.1{0.8490}
58.2{0.8499}
58.3{0.8508}
58.4{0.8517}
58.5{0.8526}
58.6{0.8536}
58.7{0.8545}
58.8{0.8554}
58.9{0.8563}
59.0{0.8572}
59.1{0.8581}
59.2{0.8590}
59.3{0.8599}
59.4{0.8607}
59.5{0.8616}
59.6{0.8625}
59.7{0.8634}
59.8{0.8643}
59.9{0.8652}
60.0{0.8660}
60.1{0.8669}
60.2{0.8678}
60.3{0.8686}
60.4{0.8695}
60.5{0.8704}
60.6{0.8712}
60.7{0.8721}
60.8{0.8729}
60.9{0.8738}
61.0{0.8746}
61.1{0.8755}
61.2{0.8763}
61.3{0.8771}
61.4{0.8780}
61.5{0.8788}
61.6{0.8796}
61.7{0.8805}
61.8{0.8813}
61.9{0.8821}
62.0{0.8829}
62.1{0.8838}
62.2{0.8846}
62.3{0.8854}
62.4{0.8862}
62.5{0.8870}
62.6{0.8878}
62.7{0.8886}
62.8{0.8894}
62.9{0.8902}
63.0{0.8910}
63.1{0.8918}
63.2{0.8926}
63.3{0.8934}
63.4{0.8942}
63.5{0.8949}
63.6{0.8957}
63.7{0.8965}
63.8{0.8973}
63.9{0.8980}
64.0{0.8988} 64.1{0.8996} 64.2{0.9003} 64.3{0.9011} 64.4{0.9018} 64.5{0.9026} 64.6{0.9033} 64.7{0.9041} 64.8{0.9048}
64.9{0.9056}
65.0{0.9063} 65.1{0.9070} 65.2{0.9078} 65.3{0.9085} 65.4{0.9092} 65.5{0.9100} 65.6{0.9107} 65.7{0.9114} 65.8{0.9121}
65.9{0.9128}
66.0{0.9135} 66.1{0.9143} 66.2{0.9150} 66.3{0.9157} 66.4{0.9164} 66.5{0.9171} 66.6{0.9178} 66.7{0.9184} 66.8{0.9191}
66.9{0.9198}
67.0{0.9205} 67.1{0.9212} 67.2{0.9219} 67.3{0.9225} 67.4{0.9232} 67.5{0.9239} 67.6{0.9245} 67.7{0.9252} 67.8{0.9259}
67.9{0.9265}
68.0{0.9272} 68.1{0.9278} 68.2{0.9285} 68.3{0.9291} 68.4{0.9298}
68.5{0.9304}
68.6{0.9311}
68.7{0.9317}
68.8{0.9323}
68.9{0.9330}
69.0{0.9336}
69.1{0.9342}
69.2{0.9348}
69.3{0.9354}
69.4{0.9361}
69.5{0.9367}
69.6{0.9373}
69.7{0.9379}
69.8{0.9385}
69.9{0.9391}
70.0{0.9397}
70.1{0.9403}
70.2{0.9409}
70.3{0.9415}
70.4{0.9421}
70.5{0.9426}
70.6{0.9432}
70.7{0.9438}
70.8{0.9444}
70.9{0.9449}
71.0{0.9455}
71.1{0.9461}
71.2{0.9466}
71.3{0.9472}
71.4{0.9478}
71.5{0.9483}
71.6{0.9489}
71.7{0.9494}
71.8{0.9500}
71.9{0.9505}
72.0{0.9511}
72.1{0.9516}
72.2{0.9521}
72.3{0.9527}
72.4{0.9532}
72.5{0.9537}
72.6{0.9542}
72.7{0.9548}
72.8{0.9553}
72.9{0.9558}
73.0{0.9563}
73.1{0.9568}
73.2{0.9573}
73.3{0.9578}
73.4{0.9583}
73.5{0.9588}
73.6{0.9593}
73.7{0.9598}
73.8{0.9603}
73.9{0.9608}
74.0{0.9613}
74.1{0.9617}
74.2{0.9622}
74.3{0.9627}
74.4{0.9632}
74.5{0.9636}
74.6{0.9641}
74.7{0.9646}
74.8{0.9650}
74.9{0.9655}
75.0{0.9659}
75.1{0.9664}
75.2{0.9668}
75.3{0.9673}
75.4{0.9677}
75.5{0.9681}
75.6{0.9686}
75.7{0.9690}
75.8{0.9694}
75.9{0.9699}
76.0{0.9703}
76.1{0.9707}
76.2{0.9711}
76.3{0.9715}
76.4{0.9720}
76.5{0.9724}
76.6{0.9728}
76.7{0.9732}
76.8{0.9736}
76.9{0.9740}
77.0{0.9744}
77.1{0.9748}
77.2{0.9751}
77.3{0.9755}
77.4{0.9759}
77.5{0.9763}
77.6{0.9767}
77.7{0.9770}
77.8{0.9774}
77.9{0.9778}
78.0{0.9781}
78.1{0.9785}
78.2{0.9789}
78.3{0.9792}
78.4{0.9796}
78.5{0.9799}
78.6{0.9803}
78.7{0.9806}
78.8{0.9810}
78.9{0.9813}
79.0{0.9816}
79.1{0.9820}
79.2{0.9823}
79.3{0.9826}
79.4{0.9829}
79.5{0.9833}
79.6{0.9836}
79.7{0.9839}
79.8{0.9842}
79.9{0.9845}
80.0{0.9848}
80.1{0.9851}
80.2{0.9854}
80.3{0.9857}
80.4{0.9860}
80.5{0.9863}
80.6{0.9866}
80.7{0.9869}
80.8{0.9871}
80.9{0.9874}
81.0{0.9877}
81.1{0.9880}
81.2{0.9882}
81.3{0.9885}
81.4{0.9888}
81.5{0.9890}
81.6{0.9893}
81.7{0.9895}
81.8{0.9898}
81.9{0.9900}
82.0{0.9903}
82.1{0.9905}
82.2{0.9907}
82.3{0.9910}
82.4{0.9912}
82.5{0.9914}
82.6{0.9917}
82.7{0.9919}
82.8{0.9921}
82.9{0.9923}
83.0{0.9925}
83.1{0.9928}
83.2{0.9930}
83.3{0.9932}
83.4{0.9934}
83.5{0.9936}
83.6{0.9938}
83.7{0.9940}
83.8{0.9942}
83.9{0.9943}
84.0{0.9945}
84.1{0.9947}
84.2{0.9949}
84.3{0.9951}
84.4{0.9952}
84.5{0.9954}
84.6{0.9956}
84.7{0.9957}
84.8{0.9959}
84.9{0.9960}
85.0{0.9962}
85.1{0.9963}
85.2{0.9965}
85.3{0.9966}
85.4{0.9968}
85.5{0.9969}
85.6{0.9971}
85.7{0.9972}
85.8{0.9973}
85.9{0.9974}
86.0{0.9976} 86.1{0.9977} 86.2{0.9978} 86.3{0.9979} 86.4{0.9980} 86.5{0.9981} 86.6{0.9982} 86.7{0.9983} 86.8{0.9984} 86.9{0.9985}
87.0{0.9986}
87.1{0.9987}
87.2{0.9988}
87.3{0.9989}
87.4{0.9990}
87.5{0.9990}
87.6{0.9991}
87.7{0.9992}
87.8{0.9993}
87.9{0.9993}
88.0{0.9994}
88.1{0.9995}
88.2{0.9995}
88.3{0.9996}
88.4{0.9996}
88.5{0.9997}
88.6{0.9997}
88.7{0.9997}
88.8{0.9998}
88.9{0.9998}
89.0{0.9998}
89.1{0.9999}
89.2{0.9999}
89.3{0.9999}
89.4{0.9999}
89.5{1.0000}
89.6{1.0000}
89.7{1.0000}
89.8{1.0000}
89.9{1.0000}
90.0{1.0000}
C51单片机C语言程序100例_Keil
目录 目录 (1) 函数的使用和熟悉********************************/ (4) 实例3：用单片机控制第一个灯亮 (4) 实例4：用单片机控制一个灯闪烁：认识单片机的工作频率 (4) 实例5：将P1口状态分别送入P0、P2、P3口：认识I/O口的引脚功能 (5) 实例6：使用P3口流水点亮8位LED (5) 实例7：通过对P3口地址的操作流水点亮8位LED (6) 实例8：用不同数据类型控制灯闪烁时间 (7) 实例9：用P0口、P1口分别显示加法和减法运算结果 (8) 实例10：用P0、P1口显示乘法运算结果 (9) 实例11：用P1、P0口显示除法运算结果 (9) 实例12：用自增运算控制P0口8位LED流水花样 (10) 实例13：用P0口显示逻辑"与"运算结果 (10) 实例14：用P0口显示条件运算结果 (11) 实例15：用P0口显示按位"异或"运算结果 (11) 实例16：用P0显示左移运算结果 (11) 实例17："万能逻辑电路"实验 (11) 实例18：用右移运算流水点亮P1口8位LED (12) 实例19：用if语句控制P0口8位LED的流水方向 (13) 实例20：用swtich语句的控制P0口8位LED的点亮状态 (13) 实例21：用for语句控制蜂鸣器鸣笛次数 (14) 实例22：用while语句控制LED (16) 实例23：用do-while语句控制P0口8位LED流水点亮 (16) 实例24：用字符型数组控制P0口8位LED流水点亮 (17) 实例25：用P0口显示字符串常量 (18) 实例26：用P0口显示指针运算结果 (19) 实例27：用指针数组控制P0口8位LED流水点亮 (19) 实例28：用数组的指针控制P0口8位LED流水点亮 (20) 实例29：用P0、P1口显示整型函数返回值 (21) 实例30：用有参函数控制P0口8位LED流水速度 (22) 实例31：用数组作函数参数控制流水花样 (23) 实例32：用指针作函数参数控制P0口8位LED流水点亮 (23) 实例33：用函数型指针控制P1口灯花样 (25) 实例34：用指针数组作为函数的参数显示多个字符串 (26) 实例35：字符函数ctype.h应用举例 (27) 实例36：内部函数intrins.h应用举例 (27) 实例37：标准函数stdlib.h应用举例 (28) 实例38：字符串函数string.h应用举例 (29) 实例39：宏定义应用举例2 (29) 1/192
C语言常用函数
Ｃ语言的常用库函数 函数1。absread()读磁盘绝对扇区函数 原形：int absread(int drive,int num,int sectnum,void *buf) 功能：从drive指定的驱动器磁盘上，sectnum指定的逻辑扇区号开始读取(通过DOS中断0x25读取)num 个(最多64K个)扇区的内容，储存于buf所指的缓冲区中。 参数：drive=0对应A盘,drive=1对应B盘。 返回值：0:成功；-1:失败。 头文件：dos.h 函数2。abswrite()写磁盘绝对扇区函数 原形：int abswrite(int drive,int nsects,int lsect,void *buffer) drive=0(A驱动器)、1(B驱动器)、 nsects=要写的扇区数(最多64K个); lsect=起始逻辑扇区号; buffer=要写入数据的内存起始地址。 功能：将指定内容写入(调用DOS中断0x26)磁盘上的指定扇区，即使写入的地方是磁盘的逻辑结构、文件、FAT表和目录结构所在的扇区，也照常进行。 返回值：0:成功；-1:失败。 头文件：dos.h 函数3。atof()将字符串转换成浮点数的函数 原形：double atof(const char *s) 功能：把s所指向的字符串转换成double类型。 s格式为:符号数字.数字E符号数字 返回值：字符串的转换值。 头文件：math.h、stdlib.h 函数4。atoi()将字符串转换成整型数的函数 原形：int atoi(const char *s) 功能：把s所指向的字符串转换成int类型。 s格式为:符号数字 返回值：字符串的转换值。若出错则返回0。 头文件：stdlib.h 函数5。atol()将字符串转换成长整型数的函数 原形：long atol(const char *s)
C语言函数知识详解
函数<一> 第一节函数的定义和返回值 一、库函数 1、一个C语言源程序无论包含了多少函数，C程序总是从main 开始执行。 2、调用C语言标准库函数时要求的include命令。 1）用户在源程序include命令中应该包含头文件： #include
#include“math.h” 例:int abs(int x)double cos(double x) 字符函数和字符串函数 调用字符函数时，要求在源文件中包含头文件”ctype.h”;调用字符串 函数时，要求在源文件 中包含头文件”string.h” 如调用：int isalpha(int ch)检查ch是否为字母。 输入输出函数：调用输入输出函数时，要求在源文件中包含头文件”stdio.h” 例：调用：putchar getchar gets puts 二、函数的定义和返回值 1、函数定义的语法 函数首部（main()） 函数1 C 语定义说明部分 言 程函数体 序 执行语句部分
C语言中常见的功能函数
C语言中常见的功能函数（应掌握的编程） 1、两个变量值的交换 void exchang(float *x,float *y) /*形参为两个变量的地铁（指针）*/ {float z; z=*x; *x=*y; *y=z; } void main() {float a,b; scanf(“%f%f”,&a,&b); exchang(&a,&b); /*因为形参是指针，所以实参必须给变量的地址，不能给变量名*/ printf(“a=%f,b=%f”,a,b); } 2、判断一个整数的奇偶 int jou(int n) /*如果是奇数返回1，否则返回0*/ { if(n%2==0) return 0; return 1; } 3、小写字符转换成大写字符 根据实参传给形参的字母，判断是否是小写字母，如果是小写字母，则转换成大写字母，否则不进行转换，函数返回转换后或原来的字符。 本函数仿照toupper()库函数的功能编写（toupper(c) 是将变量c字母转换成大写字母，如果不是小写字母不转换）。 char toupper1(char ch) {if(ch>=?a?&&ch<=?z?) ch-=32; /*小写字母比对应的大写字母ASCII码值大32*/ return ch; } 4、判断一个字符是否是字母（或数字） 根据实参传给形参的字符，判断是否是字母（或数字），如果是字母（或数字）返回1，否则返回0。此函数是根据库函数isalpha()（或isdigit()）来编写的。 int isalpha1(char ch) /*判断是否是字母*/ {if(ch>=?A?&&ch<=?Z?||ch>=?a?&&ch<=?z?) return 1; else return 0; } int isdigit1(char ch) /*判断是否是数字字符*/ {if(ch>=?0?&&ch<=?9?) return 1; else return 0; } 5、根据学生成绩，返回其等级 char fun(float cj) {char c; switch((int)cj/10) {case 10:
C语言函数大全(p开头).docx
函数大全（p开头） 61 函数名：parsfnm 功能:分析文件名 用法：char *parsfnm (char *cmdline, struct fcb *fcbptr, int option); 程序例： #include
prinif(=The current sUHus of your keyboard is,n=)； value H Peek(oxoo4p0x0017) 八 if (value 1) P S-二 f(--Right shift onm=)八 else printaRight shift 05n =) 八 if (value 2) primf(=Lefr shift onvr.r else prin-fTLen shift O 51T )； if (value &. 4) printf(=con=rol key on\n=)_ else p r i n .s =c o =r o 】 key off\n=)八 if (value Rp 8) printf(=Alr key on\n=)一 else p r i n s ->-t key 03=)
C语言常用IO函数
一些比较常用的io函数,总结了一下,一块贴出来了 stdin标准输入流 stdout标准输出流 stderr标准错误流 字符IO函数 1.int getchar() 说明：从stdin读取1个字符 返回值：成功，返回该字符；出错，返回EOF； 2.int fgetc(FILE fp) 说明：功能同getchar，默认从文件fp读取； 返回值：成功，返回该字符；出错，返回EOF； 可以重定向 3.int getc(FILE fp) 说明：功能与fgetc相同，但getc既可以被用作 函数实现，也可以被用作宏实现，并且它的编码效率 可能会更高. 可以重定向 4.int putchar(int ch) 说明：向stdout输出字符ch； 返回值：成功，返回该字符；出错，返回EOF； 5.int fputc(int c,FILE fp) 说明：功能同putchar，默认向fp输出字符ch； 返回值：成功，返回该字符；出错，返回EOF； 6.int putc(int c,FILE fp) 说明：功能与fputc相同，但putc与getc一样既可能被用作 函数实现，也可能被用作宏实现，并且它的编码效率可能会更高；可以重定向 字符串IO函数 1.char gets(char str) 说明：从stdin读取字符串(不包括'n')写入到字符串str中； 返回值：成功，返回str首地址；错误，返回NULL； 2.char fgets(char str,int N,FILE fp) 说明：默认从文件fp中读取N个字符(包括'n')写入到字符串str中，
如果实际输入字符串小于N,fgets自动添加'n'， 返回值：成功，返回字符串首地址；错误或遇到EOF，返回NULL；可以重定向 3.int puts(const char str) 说明：向stdout输出字符串str，然受输出一个'n'， 返回值：成功，返回非负值；错误，EOF； 4.int fputs(const char str,FILE fp) 说明：功能同puts，默认向文件fp写入字符串str； 返回值：成功，返回非负值；错误，EOF； 可以重定向 格式化IO函数 1.int scanf(const char format,...) 说明：根据format从stdin格式化读取N个值，并输入到... 返回值：成功，返回读取的项数；出错，返回EOF 2.int fscanf(FILE fp,const char format,...) 说明：功能同scanf，默认从文件fp读取， 返回值：成功，返回读取的项数；出错或遇到文件尾，返回EOF 可以重定向 3.int sscanf(const char buf,const char format,...) 说明：根据format从buf格式化读取N个值，并输入到... 返回值：成功，返回读取的项数；出错，返回EOF 4.int printf(const char format,...) 说明：根据format格式化数据，并输出到stdout 返回值成功，返回输出字符数；错误，返回负数； 5.int fprintf(FILE fp,const char format,...) 说明：功能同printf，默认向文件fp写入; 可以重定向 6.int sprintf(char buf,const char format,...) 说明：根据format格式化数据，并输出到buf， 返回值：成功，返回输出字符数；错误，返回负数
C语言常用函数手册
1.分类函数,所在函数库为ctype.h int isalpha(int ch) 若ch是字母('A'-'Z','a'-'z')返回非0值,否则返回0 int isalnum(int ch) 若ch是字母('A'-'Z','a'-'z')或数字('0'-'9'),返回非0值,否则返回0 int isascii(int ch) 若ch是字符(ASCII码中的0-127)返回非0值,否则返回0 int iscntrl(int ch) 若ch是作废字符(0x7F)或普通控制字符(0x00-0x1F) 返回非0值,否则返回0 int isdigit(int ch) 若ch是数字('0'-'9')返回非0值,否则返回0 int isgraph(int ch) 若ch是可打印字符(不含空格)(0x21-0x7E)返回非0值,否则返回0 int islower(int ch) 若ch是小写字母('a'-'z')返回非0值,否则返回0 int isprint(int ch) 若ch是可打印字符(含空格)(0x20-0x7E)返回非0值,否则返回0 int ispunct(int ch) 若ch是标点字符(0x00-0x1F)返回非0值,否则返回0 int isspace(int ch) 若ch是空格(' '),水平制表符('\t'),回车符('\r'), 走纸换行('\f'),垂直制表符('\v'),换行符('\n') 返回非0值,否则返回0 int isupper(int ch) 若ch是大写字母('A'-'Z')返回非0值,否则返回0 int isxdigit(int ch) 若ch是16进制数('0'-'9','A'-'F','a'-'f')返回非0值, 否则返回0 int tolower(int ch) 若ch是大写字母('A'-'Z')返回相应的小写字母('a'-'z') int toupper(int ch) 若ch是小写字母('a'-'z')返回相应的大写字母('A'-'Z') 2.数学函数,所在函数库为math.h、stdlib.h、string.h、float.h int abs(int i) 返回整型参数i的绝对值 double cabs(struct complex znum) 返回复数znum的绝对值 double fabs(double x) 返回双精度参数x的绝对值 long labs(long n) 返回长整型参数n的绝对值 double exp(double x) 返回指数函数ex的值 double frexp(double value,int *eptr) 返回value=x*2n中x的值,n存贮在eptr中double ldexp(double value,int exp); 返回value*2exp的值 double log(double x) 返回logex的值 double log10(double x) 返回log10x的值 double pow(double x,double y) 返回xy的值 double pow10(int p) 返回10p的值 double sqrt(double x) 返回+√x的值 double acos(double x) 返回x的反余弦cos-1(x)值,x为弧度 double asin(double x) 返回x的反正弦sin-1(x)值,x为弧度 double atan(double x) 返回x的反正切tan-1(x)值,x为弧度 double atan2(double y,double x) 返回y/x的反正切tan-1(x)值,y的x为弧度double cos(double x) 返回x的余弦cos(x)值,x为弧度 double sin(double x) 返回x的正弦sin(x)值,x为弧度 double tan(double x) 返回x的正切tan(x)值,x为弧度 double cosh(double x) 返回x的双曲余弦cosh(x)值,x为弧度 double sinh(double x) 返回x的双曲正弦sinh(x)值,x为弧度
单片机C语言编程实例
单片机C语言编程实例 前言 INTEL公司的MCS-51单片机是目前在我国应用得最广泛的单片机之一.随着 单片机应用技术的不断发展,许多公司纷纷以51单片机为内核,开发出与其兼容的 多种芯片,从而扩充和扩展了其品种和应用领域。 C语言已成为当前举世公认的高效简洁而又贴近硬件的编程语言之—。将C语言向单片机上的移植，始于20世纪80年代的中后期。经过十几年的努力，C语言终于成为专业化单片机上的实用高级语言。用C语言编写的8051单片机的软件，可以大大缩短开发周期，且明显地增加软件的可读性，便于改进和扩充，从而研制出规模更大、性能更完善的系统。因此，不管是对于新进入这一领域的开发者来说，还是对于有多年单片机开发经验的人来说，学习单片机的C语言编程技术都是十分必要的。. C语言是具有结构化.模块化编译的通用计算机语言,是国际上应用最广.最多的计算语言之一。C51是在通用C语言的基础上开发出的专门用于51系列单片机编程的C语言.与汇编语言相比,C51在功能上.结构上以及可读性.可移植性.可维护性等方面都有非常明显的优势。目前 最先进、功能最强大、国内用户最多的C51编译器是Keil Soft ware公司推出的KeilC51。第 一章单片机C语言入门 1.1建立您的第一个C项目 使用C语言肯定要使用到C编译器，以便把写好的C程序编译为机器码， 这样单片机才能执行编写好的程序。KEIL uVISION2是众多单片机应用开发软 件中优秀的软件之一，它支持众多不同公司的MCS51架构的芯片，它集编辑， 编译，仿真等于一体，同时还支持PLM、汇编和C语言的程序设计，它的界面 和常用的微软VC++的界面相似，界面友好，易学易用，在调试程序，软件仿真 方面也有很强大的功能。因此很多开发51应用的工程师或普通的单片机爱好者，都对它十分喜欢。 以上简单介绍了KEIL51软件，要使用KEIL51软件，必需先要安装它。KEIL51是一个商业的软件，对于我们这些普通爱好者可以到KEIL中国代理周 立功公司的网站上下载一份能编译2K的DEMO版软件，基本可以满足一般的个
单片机c语言中nop函数的使用方法和延时计算
单片机c语言中nop函数的使用方法和延时计算 标准的C语言中没有空语句。但在单片机的C语言编程中，经常需要用几个空指令产生短延时的效果。 这在汇编语言中很容易实现，写几个nop就行了。 在keil C51中，直接调用库函数： #include
第一、定义的C51中循环变量，尽量采用无符号字符型变量。 第二、在FOR循环语句中，尽量采用变量减减来做循环。 第三、在do…while，while语句中，循环体内变量也采用减减方法。这因为在C51编译器中，对不同的循环方法，采用不同的指令来完成的。 下面举例说明： unsigned char I; for(i=0;i<255;i++); unsigned char I; for(i=255;i>0;i--); 其中，第二个循环语句C51编译后，就用DJNZ指令来完成，相当于如下指令： MOV09H，＃0FFH LOOP：DJNZ09H，LOOP 指令相当简洁，也很好计算精确的延时时间。 同样对do…while，while循环语句中，也是如此 例： unsigned char n; n=255; do{n--}
单片机c语言编程控制流水灯
说了这么多了，相信你也看了很多资料了，手头应该也有必备的工具了吧！（不要忘了上面讲过几个条件的哦）。那个单片机究竟有什么 功能和作用呢？先不要着急！接下来让我们点亮一个LED（搞电子的应该知道LED是什么吧^_^） 我们在单片机最小系统上接个LED,看我们能否点亮它!对了,上面也有好几次提到过单片机最小系统了，所谓单片机最小系统就是在单片机 上接上最少的外围电路元件让单片机工作。一般只须连接晶体、VCC、GND、RST即可，一般情况下，AT89C51的31脚须接高电平。 #include
单片机C语言(非常通俗易懂)
单片机C语言（非常通俗易懂） （一） 相信很多爱好电子的朋友,对单片机这个词应该都不会陌生了吧。不过有些朋友可能只听说他叫单片机，他的全称是什么也许并不太清楚， 更不用说他的英文全称和简称了。单片机是一块在集成电路芯片上集成了一台有一定规模的微型计算机。简称为：单片微型计算机或单片机 （Single Chip Computer)。单片机的应用到处可见，应用领域广泛，主要应用在智能仪表、实时控制、通信、家电等方面。不过这一切都没 什么关系，因为我（当然也包括任何人）都是从不知道转变成知道的，再转变成精通的。现在我只想把我学习单片机的经历，详细地讲叙给大 家听听，可能有些大虾会笑话我，想：那么简单的东西还在这里卖弄。但是你错了，我只是把我个人学习的经历讲述一遍而已，仅仅对那些想 学习单片机，但又找不到好方法或者途径的朋友，提供一个帮助，使他们在学习过程中，尽量少走些弯路而已！ 首先，你必须有学习单片机的热情，不是说今天去图书馆看了一个下午关于单片机的书，而明天玩上半天，后天就不知道那个本书在讲什 么东西了。还是先说说我吧，我从大二的第一个学期期末的时候才开始接触单片机，但在这之前，正如上面所说的：我知道有种芯片叫单片机， 但是具体长成什么样子，却一点也不知道！看到这里很多朋友一定会忍不住发笑。嘿嘿，你可千万别笑，有些大四毕业的人也同样不知道单片 机长成什么样子呢！而我对单片机的痴迷更是常人所不能想象的地步，大二的期末考试，我全放弃了复习，每当室友拿着书在埋头复习的时候， 我却捧着自己从图书馆借的单片机书在那看，虽然有很多不懂，但是我还是坚持了下来，当时我就想过，为了单片机值不值得我这样去付出， 或许这也是在一些三流学校的好处吧，考试挂科后，明年开学交上几十元一门的补考费，应该大部分都能过了。于是，我横下一条心，坚持看 我的单片机书和资料。 当你明白了单片机是这么一回事的时候，显而易见的问题出来了：我要选择那种语言为单片机编写程序呢？这个问题，困扰了我好久。具 体选择C51还是A51呢？汇编在我们大二之前并没有开过课，虽然看着人家的讲解，很容易明白单片机的每一时刻的具体工作情况，但是一合上 书或者资料，自己却什么也不知道了，根本不用说自己写程序了。于是，我最终还是决定学C51，毕竟C51和我们课上讲的C语言，有些类似， 编程的思想可以说是相通的。而且C51还有更大的优点就是编写大程序时的优越性更不言而喻，当然在那时，我并没有想的那么深远，C51的特 点，还是在后来的实践过程中，渐渐体会到的！朋友如果你选择了C51,那么请继续往下看,如果你选择了A51,那么你可以不要看了!因为下面讲 的全是C方面的,完全在浪费你的时间! 呵呵 ^_^ 第二，既然你想学好单片机，你必须得舍得花钱，如果不买些芯片回来自己动手焊焊拆拆的(但是在后期会介绍给大家一个很好用的硬件 仿真软件,并不需要你用实验板和仿真器了,直接在你的PC上完成,但是软件毕竟是软件,从某个特定的意义上来说是并不能代替硬件的)，即使
单片机C语言常用头文件
函数原形的头文件读者可参考返回非整型值的函数 assert.h - assert(), 声明宏 ctype.h –字符类型函数 float.h –浮点数原形 limits.h –数据类型的大小和范围 math.h –浮点运算函数 stdarg.h –变量参数表. stddef.h –标准定义 stdio.h –标准输入输出IO 函数 stdlib.h –包含内存分配函数的标准库 string.h –字符串处理函数 3 字符类型库 下列函数按照输入的ACS II 字符集字符分类使用这些函数之前应当用"#include
C语言函数大全
功能: 异常终止一个进程 用法: void abort(void) 函数名: abs 功能: 求整数的绝对值 用法: int abs(int i) 函数名: absread, abswirte 功能: 绝对磁盘扇区读、写数据 用法: int absread(int drive, int nsects, int sectno, void *buffer) int abswrite(int drive, int nsects, in tsectno, void *buffer 函数名: access 功能: 确定文件的访问权限 用法: int access(const char *filename, int amode) 函数名: acos 功能:反余弦函数 用法: double acos(double x) 函数名: allocmem 功能: 分配DOS存储段 用法:int allocmem(unsigned size, unsigned *seg) 函数名: arc 功能: 画一弧线 用法:void far arc(int x, int y, int stangle, int endangle, int radius)函数名: asctime 功能: 转换日期和时间为ASCII码 用法:char *asctime(const struct tm *tblock) 函数名: asin 功能:反正弦函数 用法: double asin(double x) 函数名: assert 功能: 测试一个条件并可能使程序终止 用法:void assert(int test) 函数名: atan 功能: 反正切函数 用法: double atan(double x)
C语言常见基本词汇及词汇解释
C语言常用基本词汇及其他提示语运算符与表达式： 1.constant 常量 2. variable 变量 3. identify 标识符 4. keywords 关键字 5. sign 符号 6. operator 运算符 7. statement语句 8. syntax 语法 9. expression 表达式 10. initialition初始化 11. number format 数据格式 12 declaration 说明 13. type conversion 类型转换 14.define 、definition 定义 条件语句： 1.select 选择 2. expression 表达式 3. logical expression 逻辑表达式 4. Relational expression 关系表达式 5.priority优先
6. operation运算 7.structure 结构 循环语句： 1.circle 循环 2. condition 条件 3. variant 变量 4. process过程 5.priority优先 6. operation运算 数组： 1. array 数组 2. reference 引用 3. element 元素 4. address 地址 5. sort 排序 6. character 字符 7. string 字符串 8. application 应用函数： 1.call 调用 2.return value 返回值 3.function 函数
4. declare 声明 5. `parameter 参数 6.static 静态的 7.extern 外部的 指针： 1. pointer 指针 2. argument 参数 3. array 数组 4. declaration 声明 5. represent 表示 6. manipulate 处理 结构体、共用体、链表： 1 structure 结构 2 member成员 3 tag 标记 4 function 函数 5 enumerate 枚举 6 union 联合（共用体） 7 create 创建 8 insert 插入 9 delete 删除 10 modify 修改
单片机C语言练习题
C语言习题集 习题一 一．填空题 1．C程序是由（）构成的，一个C程序中至少包含（）。因此，( ) 是C程序的基本单位。 2. 函数体是有符号____开始，符号____结束。函数体当中，前面是变量的____部分，后面变量的____部分。3．一个C源程序中至少应包括一个_______。 4．在一个C源程序中，注释部分两侧的分界符分别为_____和________。在C语言的每条语句后面都要有____结束 二．判断题 1．一个C程序的执行总是从该程序的main函数开始，在main函数最后结束。【】 2．main函数必须写在一个C程序的最前面。【】 3．一个C程序可以包含若干的函数。【】 4．C程序的注释部分可以出现在程序的任何位置，它对程序的编译和运行不起任何作用。但是可以增加程序的可读性。【】 5．C程序的注释只能是一行。【】 6．C程序的注释不能是中文文字信息。【】 三、选择题 1 一个C程序的执行是从________。 (A)本程序的main函数开始，到main函数结束。 (B)本程序的第一个函数开始，到本程序文件的最后一个函数结束。 (C) 本程序的main函数开始，到本程序文件的最后一个函数结束。 (D)本程序的第一个函数开始，到本程序main函数结束。 2 以下叙述不正确的是_________。 (A)一个C源程序可由一个或多个函数组成。 (B)一个C源程序必须包含一个main函数。 (C) 程序的基本组成单位是函数。 (D)在C程序中，/**/类的注释说明只能位于一条语句的后面 3 C语言规定：在一个源程序中，main函数的位置___。 (A)必须在最开始(B)必须在所有函数的后面 (C)可以任意(D)必须在最后 四．程序阅读 1、找出该程序中的错误并改正。 #include
C语言函数习题及答案
第6章函数习题 一、选择题 1. 一个完整的C源程序是【】。 A）要由一个主函数或一个以上的非主函数构成 B）由一个且仅由一个主函数和零个以上的非主函数构成 C）要由一个主函数和一个以上的非主函数构成 D）由一个且只有一个主函数或多个非主函数构成 2. 以下关于函数的叙述中正确的是【】。 A）C语言程序将从源程序中第一个函数开始执行 B）可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行 C）C语言规定必须用main作为主函数名，程序将从此开始执行，在此结束 D）main可作为用户标识符，用以定义任意一个函数 3. 以下关于函数的叙述中不正确的是【】。 A）C程序是函数的集合，包括标准库函数和用户自定义函数 B）在C语言程序中，被调用的函数必须在main函数中定义 C）在C语言程序中，函数的定义不能嵌套 D）在C语言程序中，函数的调用可以嵌套 4. 在一个C程序中,【】。 A）main函数必须出现在所有函数之前 B）main函数可以在任何地方出现 C）main函数必须出现在所有函数之后 D）main函数必须出现在固定位置 5. 若在C语言中未说明函数的类型，则系统默认该函数的数据类型是【】 A）float B）long C）int D）double 6. 以下关于函数叙述中，错误的是【】。 A）函数未被调用时，系统将不为形参分配内存单元 B）实参与形参的个数应相等，且实参与形参的类型必须对应一致 C）当形参是变量时，实参可以是常量、变量或表达式 D）形参可以是常量、变量或表达式 7. C程序中各函数之间可以通过多种方式传递数据，下列不能用于实现数据传递的方式是【】。 A）参数的形实（哑实）结合 B）函数返回值 C）全局变量 D）同名的局部变量 8. 若函数调用时参数为基本数据类型的变量，以下叙述正确的是【】。 A）实参与其对应的形参共占存储单元 B）只有当实参与其对应的形参同名时才共占存储单元 C）实参与对应的形参分别占用不同的存储单元 D）实参将数据传递给形参后，立即释放原先占用的存储单元 9. 函数调用时,当实参和形参都是简单变量时，他们之间数据传递的过程是【】。 A）实参将其地址传递给形参，并释放原先占用的存储单元 B）实参将其地址传递给形参，调用结束时形参再将其地址回传给实参 C）实参将其值传递给形参，调用结束时形参再将其值回传给实参
51单片机C语言程序设计复习资料
2013-2014学年上期51单片机C语言程序设计重修复习提纲考试方式：闭卷考试。 考试题型： 填空题（每空1分，共18分）；单项选择题（每空2分，共18分）；问答及计算题（每题4分，共16分）；编程及程序阅读题（5小题，共48分）。 考试分数： 卷面成绩70%+平时成绩15%+实验成绩15%，未缺席、无课堂违纪、作业全交且认真完成的同学平时成绩可获得满分，缺席一次平时成绩扣30分，实验好评次数3次以上且实验报告全优的同学实验成绩可得满分，实验缺席一次扣30分。缺席实验和旷课共3次以上者，无考试资格。 考试时间： 18周周一（12月30日）下午14：00：16：00，考试地点：具体考室另行通知希望大家认真复习，认真听讲，不懂就问，考试成绩不及格允许查卷，如查卷卷面批阅无误成绩不做更改。 编程题为实验或实验类似的题目有3题，其余2题也取自课堂讲授例题，请务必认真复习。第一章单片机概述及单片机知识回顾 掌握什么是单片机、单片机的应用、常见单片机类型、十进制、十六进制、二进制数制转换知识。掌握单片机的硬件组成、CPU的结构、程序计数器PC的功能、存储器结构、机器周期的计算、会画出单片机的最小系统电路图及回答单片机最小系统的组成。 第二章C51语言程序设计基础（本章填空题和选择题比重较大请务必认真复习）掌握C51语言进行软件开发与汇编语言相比的优点、掌握C51的数据类型、特殊功能位的定义、C51的基本运算（位运算重点复习）、数组的定义、C51的结构及函数。 第三章AT89S51片内并行端口及编程（本章有编程题） 掌握P0-P3并行端口的特点，会开关量检测及流水灯程序的编程。 第四章AT89S51单片机的中断系统（本章有编程题） 掌握中断系统的结构、中断请求响应被满足的条件、外部中断的触发选择方式、外部中断的使用与编程。 第五章AT89S51单片机的定时器/计数器（本章有编程器） 掌握定时器的结构，TOMD及TCON的使用，定时器方式0和方式1的特点、会计算定时器初值，会用定时器中断产生PWM波形，会用定时器对外部事件进行计数。 第六章AT89S51单片机的串行口（本章有计算题） 掌握串行通信的基础知识（课本没有的内容请参照课堂讲授笔记或PPT）、串行口的四种工作方式的特点、会计算奇偶校验码、会根据波特率计算T1的初值。 第七章AT89S51单片机与输入/输出外设接口（本章有编程题） 掌握数码管动态显示的原理、掌握矩阵式键盘的原理与编程（矩阵键盘编程必考，但不会考4X4键盘）。 第八章AT89S51单片机与D/A与A/D转换器的接口（本章有编程题） 掌握AD与DA转换的接口、ADC和DAC的技术指标、常用AD和DA转换器。掌握ADC0809和TLC2543的使用与编程（2器件其中之一有编程题）。 第九章AT89S51单片机应用系统与调试（本章有编程题） 掌握单片机应用系统的软件抗干扰方法。
C语言常用函数名及用法
字符函数和字符串函数 头文件：字符串函数头文件：#include
5. Scanf(“%d%c%f”,&a,&b,&c); 输入时1234a123h26↙在输入遇到时空格回车 tab或其他非法输入就会认定输入完毕 Gets (字符数组)：读入字符串函数 Gets（str）从键盘键入a b↙括号里为字符数组str的起始地址，Puts（字符数组）：输出字符串函数 Strcat(字符数组1，字符数组2)：字符串连接函数（2连接在1后面） Strcpy和strncpy:字符串复制函数 Strcpy(字符数组1，字符数组2)：将2复制到1 数组1 要为数组名，字符串2可以为数组名或者字符串 Strncpy(str1,str2,2)：将str2的前两个字符复制到str1，取代str1的前两个字符 Strcmp:字符串比较函数 Strcmp(str1,str2):相等则为0（对字符串自左向右逐个字母进行比较） Strlen(字符数组)：测字符串的实际长度 Strlwr（字符串）将字符串转换为大写 Strupr（字符串）将字符串转换为小写