广西经贸职业技术学院论坛

标题: 学习C语言的方法 [打印本页]
作者: chnzw520    时间: 2009-10-16 01:58
标题: 学习C语言的方法
学习C语言的方法
7 _& K& D1 s$ X) y5 S1 `) l1 |( |- m. P0 b4 b
在初学C语言时，可能会遇到有些问题理解不透，或者表达方式与以往数学学习中不同（如运算符等），这就要求不气馁，不明白的地方多问多想，鼓足勇气进行学习，待学完后面的章节知识，前面的问题也就迎刃而解了，这一方面我感觉是我们同学最欠缺，大多学不好的就是因为一开始遇到困难就放弃，曾经和好多同学谈他的问题，回答是听不懂、不想听、放弃这样三个过程，我反问，这节课你听过课吗？回答又是没有，根本就没听过课，怎么说自己听不懂呢？相应的根本就没学习，又谈何学的好？ 3 E; T5 m; h3 c+ Z

3 d( e% V; h2 s/ k　　学习C语言始终要记住“曙光在前头”和“千金难买回头看”，“千金难买回头看”是学习知识的重要方法，就是说，学习后面的知识，不要忘了回头弄清遗留下的问题和加深理解前面的知识，这是我们学生最不易做到的，然而却又是最重要的。学习C语言就是要经过几个反复，才能前后贯穿，积累应该掌握的C知识。 0 W9 n4 D2 }% O) Q; T
) w7 V1 C8 q2 R% r7 j5 L
　　那么，我们如何学好《C程序设计》呢？
1 V: H" `0 g" w- u8 C8 p. u: i& m2 ^, R: O0 W8 o
　　一．学好C语言的运算符和运算顺序 - G7 D2 ]4 f$ U: c/ U
" R9 E2 y1 V" d' [; j9 T# |7 \! Z+ R
　　这是学好《C程序设计》的基础，C语言的运算非常灵活，功能十分丰富，运算种类远多于其它程序设计语言。在表达式方面较其它程序语言更为简洁，如自加、自减、逗号运算和三目运算使表达式更为简单，但初学者往往会觉的这种表达式难读，关键原因就是对运算符和运算顺序理解不透不全。当多种不同运算组成一个运算表达式，即一个运算式中出现多种运算符时，运算的优先顺序和结合规则显得十分重要。在学习中，只要我们对此合理进行分类，找出它们与我们在数学中所学到运算之间的不同点之后，记住这些运算也就不困难了，有些运算符在理解后更会牢记心中，将来用起来得心应手，而有些可暂时放弃不记，等用到时再记不迟。 $ m3 ?' {8 x7 b( b' f2 ]

+ X* q1 s% H& i7 d+ {　　先要明确运算符按优先级不同分类，《C程序设计》运算符可分为15种优先级，从高到低，优先级为1 ~ 15，除第2、13级和第14级为从右至左结合外，其它都是从左至右结合，它决定同级运算符的运算顺序.
7 _# H% _  `% D) E5 i- _
7 h8 g" p9 n1 U; ]* A# t　　二．学好C语言的四种程序结构
7 A* Y% A6 `' {% m. @& O$ u! G! r( q. ?' v7 O! m6 }
　　（1）顺序结构 4 H8 F, g2 G+ h4 X$ j

% [) X( D+ E" F% M　　顺序结构的程序设计是最简单的，只要按照解决问题的顺序写出相应的语句就行，它的执行顺序是自上而下，依次执行。 % m* i# b# v/ d1 i& H, U2 W

0 r! m4 C* P! h3 N- s8 Q　　例如；a = 3，b = 5，现交换a，b的值，这个问题就好像交换两个杯子水，这当然要用到第三个杯子，假如第三个杯子是c，那么正确的程序为： c = a； a = b； b = c； 执行结果是a = 5，b = c = 3如果改变其顺序，写成：a = b； c = a； b = c； 则执行结果就变成a = b = c = 5，不能达到预期的目的，初学者最容易犯这种错误。 顺序结构可以独立使用构成一个简单的完整程序，常见的输入、计算，输出三步曲的程序就是顺序结构，例如计算圆的面积，其程序的语句顺序就是输入圆的半径r，计算s = 3.14159*r*r,输出圆的面积s。不过大多数情况下顺序结构都是作为程序的一部分，与其它结构一起构成一个复杂的程序，例如分支结构中的复合语句、循环结构中的循环体等。
3 M( y$ Z3 |+ `+ {) G/ l0 P! l
  t* _- |5 G5 Y" V6 h3 I　　（2） 分支结构
' L9 F, ~$ p* J2 m- o: H3 s3 i: u( H: j: M
　　顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构。分支结构的执行是依据一定的条件选择执行路径，而不是严格按照语句出现的物理顺序。分支结构的程序设计方法的关键在于构造合适的分支条件和分析程序流程，根据不同的程序流程选择适当的分支语句。分支结构适合于带有逻辑或关系比较等条件判断的计算，设计这类程序时往往都要先绘制其程序流程图，然后根据程序流程写出源程序，这样做把程序设计分析与语言分开，使得问题简单化，易于理解。程序流程图是根据解题分析所绘制的程序执行流程图。
; V8 a/ i& a1 a/ \1 u8 S' z
( l; P. Y, c* W$ D　　学习分支结构不要被分支嵌套所迷惑，只要正确绘制出流程图，弄清各分支所要执行的功能，嵌套结构也就不难了。嵌套只不过是分支中又包括分支语句而已，不是新知识，只要对双分支的理解清楚，分支嵌套是不难的。下面我介绍几种基本的分支结构。
" V: l( g1 ^  V$ W* o9 m2 \$ L1 u$ q7 h4 ?* A/ B4 A" y
　　①if(条件) 8 s# W2 b: l# k; p' {7 C! I7 M* t
/ j1 J# a# k5 O0 N; N6 {, F: L" p
　　{分支体}
* d+ o; S! g5 ^% Z% Q6 U- T
% s. R" d5 k, K" }6 q) q. W" [　　这种分支结构中的分支体可以是一条语句，此时“{ }”可以省略，也可以是多条语句即复合语句。它有两条分支路径可选，一是当条件为真，执行分支体，否则跳过分支体，这时分支体就不会执行。如：要计算x的绝对值，根据绝对值定义，我们知道，当x>=0时，其绝对值不变，而x<0时其绝对值是为x的反号，因此程序段为：if(x<0) x=-x;
' R* B1 e# M! S) e) ^
9 c. r: p! Y0 k　　②if(条件)
. e4 k6 ^; L& v4 s
* `+ ~$ }5 L5 j! U  d; Q: }　　{分支1} ! {2 X7 g4 Y7 x& y" M

' ~4 p% l8 v9 b* f　　else
9 ^+ J# P  u7 k! O* u( ~" F% J! p4 S2 ~+ j7 a" C- f! a! |
　　{分支2}
. T0 T5 P' ^) e3 w& }! a) X- m) {+ _$ ^/ T- D
　　这是典型的分支结构，如果条件成立，执行分支1，否则执行分支2，分支1和分支2都可以是1条或若干条语句构成。如：求ax^2+bx+c=0的根
( o% _+ U: o1 W) k2 l( F: O( }. V7 Y9 e0 ?8 W( t5 k
　　分析：因为当b^2-4ac>=0时,方程有两个实根，否则（b^2-4ac<0）有两个共轭复根。其程序段如下：
8 U8 }$ e1 _0 e4 z! J. I. g
' h7 U. k, ^/ E0 V　　d=b*b-4*a*c; ; Z  I  R0 E' ~& K; g* ^
( H6 o. D9 A! B7 ]( ]$ z
　　if(d>=0)
) C# u, U7 R5 X- r3 `9 i2 h4 _  g9 N2 u
　　{x1=(-b+sqrt(d))/2a;
, K2 ]0 h  V5 s3 Z) t$ m
5 i# c2 u! t# E% ]3 r9 J　　x2=(-b-sqrt(d))/2a;
; h& e# O+ i7 [. U9 \0 v" g4 j6 R! O8 ]& p) F( n. e) E
　　printf(“x1=%8.4f,x2=%8.4f\n”,x1,x2); + o. J4 p2 Q6 O( f2 _

, E) e: L* s$ \9 C, u/ G  N　　}
- a3 o! t9 Q- v1 A( `* a& f$ [! d1 O! }- y3 K
　　else ; C! {0 |! X0 f8 S1 D# j& ?( z

  [* q  J, P8 C2 G　　{r=-b/(2*a);
! o! x  m  k1 [9 M$ U$ @
. p* h" [* z; }0 H/ M- j- X9 s　　i =sqrt(-d)/(2*a); . o/ p) v% F# u# Z: A  m9 Z
) K& |: Y/ v  M9 w/ _
　　printf(“x1=%8.4f+%8.4fi\n”r, i); 7 Q) W, U7 U* E

1 G2 S" ^6 Z8 \4 x6 K　　printf(“x2=%8.4f-%8.4fi\n”r,i) ! W7 F! _/ y8 y! y
) r& x: r4 ?1 L# Z9 B
　　}
5 h- k3 R  j+ {+ [5 B0 [; p. Z7 m  ~! U& ?- U0 S
　　③嵌套分支语句：其语句格式为： , h" o' r/ ]* E
; b1 s9 s+ V) V' s5 V0 T  D0 u2 e% L% a9 m
　　if(条件1) {分支1}；
; C# y: R0 \) s- C! S4 d) K4 m' l# p+ y' |& q' {7 S
　　else if（条件2） {分支2} 5 c/ Z; w2 Y/ w* }7 T6 g, D
8 W& w" e# ]( F& q
　　else if（条件3） {分支3} $ R% c% V9 c* ^+ H0 @3 @% V% k# ?
+ N, q5 O& e- Q9 c3 G% }3 G
　　…… 7 H# V( K+ E! e3 ]" l

( w& J) w* F9 ~/ Y5 }2 b6 h　　else if（条件n） {分支n} ( f  {0 M6 o  B4 J
$ N; u6 x' f9 L6 i: T$ S2 p
　　else {分支n+1}
9 d4 I5 b2 |, l$ ^& p
; f* R2 F  m7 ^; \8 Y# d5 f1 q/ g　　嵌套分支语句虽可解决多个入口和出口的问题，但超过3重嵌套后，语句结构变得非常复杂，对于程序的阅读和理解都极为不便，建议嵌套在3重以内，超过3重可以用下面的语句。 0 |0 T" W& u8 {; l, f6 ~
5 g' I% B- Y1 z! Y" Q6 u& [0 w
　　④switch开关语句：该语句也是多分支选择语句，到底执行哪一块，取决于开关设置，也就是表达式的值与常量表达式相匹配的那一路，它不同if…else 语句，它的所有分支都是并列的，程序执行时，由第一分支开始查找，如果相匹配，执行其后的块，接着执行第2分支，第3分支……的块，直到遇到break语句；如果不匹配，查找下一个分支是否匹配。这个语句在应用时要特别注意开关条件的合理设置以及break语句的合理应用。
: g, E8 a+ ]! Q4 @/ T7 D9 ~1 U$ A  _! `7 x1 d1 G: R
　　（3）循环结构：
. n3 R: q- ]* ~+ L- |5 ^% m% c$ W2 S
　　循环结构可以减少源程序重复书写的工作量，用来描述重复执行某段算法的问题，这是程序设计中最能发挥计算机特长的程序结构，C语言中提供四种循环，即goto循环、while循环、do ?Cwhile循环和for循环。四种循环可以用来处理同一问题，一般情况下它们可以互相代替换，但一般不提倡用goto循环，因为强制改变程序的顺序经常会给程序的运行带来不可预料的错误，在学习中我们主要学习while、do…while、for三种循环。常用的三种循环结构学习的重点在于弄清它们相同与不同之处，以便在不同场合下使用，这就要清楚三种循环的格式和执行顺序，将每种循环的流程图理解透彻后就会明白如何替换使用，如把while循环的例题，用for语句重新编写一个程序，这样能更好地理解它们的作用。特别要注意在循环体内应包含趋于结束的语句（即循环变量值的改变），否则就可能成了一个死循环，这是初学者的一个常见错误。 - }" I5 V' `( _

2 b$ o5 t% p% X. y1 R/ f　　在学完这三个循环后，应明确它们的异同点：用while和do…while循环时，循环变量的初始化的操作应在循环体之前，而for循环一般在语句1中进行的；while 循环和for循环都是先判断表达式，后执行循环体，而do…while循环是先执行循环体后判断表达式，也就是说do…while的循环体最少被执行一次，而while 循环和for就可能一次都不执行。另外还要注意的是这三种循环都可以用break语句跳出循环，用continue语句结束本次循环，而goto语句与if构成的循环，是不能用break和 continue语句进行控制的。
9 r3 P* q. P# c7 z& d9 I0 `! {% ?3 |* }; _2 y
　　顺序结构、分支结构和循环结构并不彼此孤立的，在循环中可以有分支、顺序结构，分支中也可以有循环、顺序结构，其实不管哪种结构，我们均可广义的把它们看成一个语句。在实际编程过程中常将这三种结构相互结合以实现各种算法，设计出相应程序，但是要编程的问题较大，编写出的程序就往往很长、结构重复多，造成可读性差，难以理解，解决这个问题的方法是将C程序设计成模块化结构。
$ `- `6 a0 `( E% E7 X4 d
' N$ v4 ]$ m! l) ~　　(4)模块化程序结构 7 i. X# S( G7 A, d6 b+ F9 U9 ]4 H

6 i8 x7 W' n9 d　　C语言的模块化程序结构用函数来实现，即将复杂的C程序分为若干模块，每个模块都编写成一个C函数，然后通过主函数调用函数及函数调用函数来实现一大型问题的C程序编写，因此常说：C程序=主函数+子函数。 因此，对函数的定义、调用、值的返回等中要尤其注重理解和应用，并通过上机调试加以巩固。 4 y8 X5 s2 c  {$ G" X
& s: x; R5 x3 q$ Q7 T' r
　　三．掌握一些简单的算法
8 w( m4 n, m5 e# ^6 `6 \/ `$ |+ s& Q  l& t; {  l  n9 J9 g
　　编程其实一大部分工作就是分析问题，找到解决问题的方法，再以相应的编程语言写出代码。这就要求掌握算法，根据我们的《C程序设计》教学大纲中，只要求我们掌握一些简单的算法，在掌握这些基本算法后，要完成对问题的分析就容易了。如两个数的交换、三个数的比较、选择法排序和冒泡法排序，这就要求我们要清楚这些算法的内在含义   u- b; ?9 s% @8 r! E9 W/ \" {0 X" T  K
& u, G% V: l* L& N
　　结语：当我们把握好上述几方面后，只要同学们能克服畏难、厌学、上课能专心听讲，做好练习与上机调试，其实C语言并不难学 * r9 V# M4 f5 D# ~5 K( i

$ M9 u+ J- K- d$ _　　C源程序的关键字--------------------------------------------------------------------------------------- ( o9 `+ X7 h# `$ R' p4 H: J1 d

6 c* n: d3 o; w8 u6 u　　所谓关键字就是已被C语言本身使用, 不能作其它用途使用的字。例如关键字不能用作变量名、函数名等
0 g# }. Z4 \8 G0 i5 r* m! r5 |! _+ P# p# }' X/ V& ~
　　由ANSI标准定义的C语言关键字共32个 : 6 m6 V4 I! p1 d! B; G3 ]/ ]9 h

0 j& ]& L* t. J, |: J' ^　　auto double int struct break else long switch
1 {4 |0 D7 m( S  U4 P# B1 S4 V
" z/ z( j5 W! E& S/ @　　case enum register typedef char extern return union
# O) g# D. z# |
) v+ `+ D' c. V% b; T2 `　　const float short unsigned continue for signed void 6 [2 \) v; g; {8 {6 h0 R9 t% J

2 p1 F- m3 I' [( \* @+ R　　default goto sizeof volatile do if while static
& Z$ J" S" \. S! r
2 {6 X8 J0 V* I) x　　根据关键字的作用，可以将关键字分为数据类型关键字和流程控制关键字两大类。
/ |3 ^& F& w* O4 v' ^7 V* @: \- ]- M% N7 m- Z: f
　　1 数据类型关键字 ) L% ~& D6 Q  B! R

, y/ U+ F! D( G! {9 ]1 ^" J, [4 G　　A基本数据类型（5个） ! Q, }# ~5 e8 b8 O

6 d# q! V6 W7 b* D; a+ {7 |) d　　void ：声明函数无返回值或无参数，声明无类型指针，显式丢弃运算结果
# \% ]) v* m! v: @
: y' I# C) q7 m9 h, ?2 y8 K" l" }　　char ：字符型类型数据，属于整型数据的一种
% a8 w( q. n' {8 I  L: @' n: |, @2 l' ^& n
　　int ：整型数据，通常为编译器指定的机器字长
0 W4 I9 ~& M8 Y+ F4 @6 I( j
. p: X' d7 J$ W7 U' n　　float ：单精度浮点型数据，属于浮点数据的一种
- ?8 c( v% M- k8 T6 J5 |( m. p/ h0 h2 \/ y) Z- r, a  @
　　double ：双精度浮点型数据，属于浮点数据的一种
% }# g7 x' U8 a8 s! r& H
/ ]# O/ R" O, T( K/ Q# b　　B 类型修饰关键字（4个） ' X. {$ H! D; Z
% z( o. C) d4 M  N. }
　　short ：修饰int，短整型数据，可省略被修饰的int。
6 {0 B! ?$ C. Y& D
# _8 x. B. F( B$ e5 C9 b　　long ：修饰int，长整形数据，可省略被修饰的int。
0 ~, a8 k6 z4 r/ Y7 [* Z4 Z% n* K" D: X0 F' K; J* K
　　signed ：修饰整型数据，有符号数据类型
( W: X- A1 D% ]; y$ U4 |' f) g5 A) P
　　unsigned ：修饰整型数据，无符号数据类型 0 r& B$ C. v$ y  F
5 K" v0 x7 O+ n6 V+ P; j  T
　　C 复杂类型关键字（5个）
: N. `" [) b6 j# e) t: {% j
, M8 N' P% J& L2 o0 B' n　　struct ：结构体声明
  x% o; j/ U7 h7 z4 z0 b* [7 }0 i5 |) J8 o6 _( q: B8 J* I
　　union ：共用体声明 ! N9 T% B4 [3 ]. [( z( K" h1 k* U

; T/ g+ U3 ~. G' V" k- O8 g　　enum ：枚举声明 . U1 }& R  r3 ]
* a1 q& j1 u  ?: t  |4 E
　　typedef ：声明类型别名 ! V  ?; v2 p2 R
2 u& j9 M6 a4 ]# f/ X8 p
　　sizeof ：得到特定类型或特定类型变量的大小 6 g% @7 w) v( a4 y2 m
9 Y" o' A5 a: T5 ]( ?! I
　　D 存储级别关键字（6个） 7 f4 P, j( X/ x3 L- o. h% M

' x  H! ], ~% C, Y8 }  u6 B' O　　auto ：指定为自动变量，由编译器自动分配及释放。通常在栈上分配 8 ~* j- |. B7 \8 m6 \
; _3 y( u  j4 e/ Q. H  s( P9 t
　　static ：指定为静态变量，分配在静态变量区，修饰函数时，指定函数作用域为文件内部
! ?$ X7 U7 l3 `9 O3 G, q9 V2 `" n  X$ V+ ?( F
　　register ：指定为寄存器变量，建议编译器将变量存储到寄存器中使用，也可以修饰函数形参，建议编译器通过寄存器而不是堆栈传递参数 * Q/ w8 z, x8 O! J5 D

7 d) N+ L; q* G, r3 U1 P　　extern ：指定对应变量为外部变量，即标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。
' m. J3 K% y) S: G7 l# L( s2 B+ y1 N% v' U
　　const ：与volatile合称“cv特性”，指定变量不可被当前线程/进程改变（但有可能被系统或其他线程/进程改变） ' J1 B2 U3 D4 A4 n
* p. S1 G- W% V# [6 b
　　volatile ：与const合称“cv特性”，指定变量的值有可能会被系统或其他进程/线程改变，强制编译器每次从内存中取得该变量的值 7 R' U. C0 \7 Q# x
! J; d; Q5 K( E. ^+ p
　　2 流程控制关键字 6 W* r2 e2 E1 t

) m3 ?% V- I* O0 V　　A 跳转结构（4个）
3 \) \% J3 I" G2 V$ d
1 k6 c0 n0 R- a; n  i　　return ：用在函数体中，返回特定值（或者是void值，即不返回值）
% F; c' |# B: Q3 K& V' v: R
5 w, U/ Q! z0 z　　continue ：结束当前循环，开始下一轮循环
8 M4 n1 q( N; y1 ]2 f4 J
) m: g% c7 I+ M% P# l* h　　break ：跳出当前循环或switch结构 , y4 i0 I; v4 n4 J7 B' A* ?# l- |
' }. h& b% w+ G" P" P' x+ b
　　goto ：无条件跳转语句 7 i3 K' l! L% b
' _: E% Y) Q! }, O. Z( S
　　B 分支结构（5个）
7 N  L$ [" q6 k0 J5 t4 ^) H" T
4 h- q- }3 w# K( f　　if ：条件语句 # w) R. b6 [5 Z) Y2 v

! k- X. V4 v& D　　else ：条件语句否定分支（与if连用） 5 i0 N2 y6 D2 f

8 {# V& d+ M3 F　　switch ：开关语句（多重分支语句） 3 G* Q! z4 ?9 l, c- _0 J
8 E* H$ F: m6 e
　　case ：开关语句中的分支标记 & o* ^8 `; F, h
/ ~) Z, n$ e6 v# ~9 q
　　default ：开关语句中的“其他”分治，可选。 1 C# r3 m( ~; D$ C) \( j+ ^, S2 z
5 i/ X) H  s- y* ]& n+ y
　　C 循环结构（3个）
0 Z* `3 U0 g% m. V+ Q( n
( B( R7 @! b; v" H: }　　for ：for循环结构，for(1;2;3)4;的执行顺序为1->2->4->3->2...循环，其中2为循环条件
! y; t) X- o' m+ R; u5 P/ P6 B) E* E: T# a( x
　　do ：do循环结构，do 1 while(2); 的执行顺序是 1->2->1...循环，2为循环条件
' I0 L5 u: H$ M# _5 ]) M
8 O3 w/ b$ y2 D1 ?9 P7 V* q( g　　while ：while循环结构，while(1) 2; 的执行顺序是1->2->1...循环，1为循环条件 % K+ i- j  [3 `4 s
/ F+ \5 Y7 p7 P2 Q! E
　　以上循环语句，当循环条件表达式为真则继续循环，为假则跳出循环。
作者: fxbaobao    时间: 2009-10-16 08:23
这文章应该对新生有所帮助。
, ~/ w' l2 t, b" _: j1 c3 T. I楼主能有针对性的发贴非常好啊。
+ p# N: |* x, k0 |$ C不过，现在新生好像都还没有电脑吧。没见有你的同学来帮你顶贴哦
作者: Photoby    时间: 2009-10-21 08:07
新生学得呢么快？学好了你们要帮我编程！！
作者: chnzw520    时间: 2009-10-21 12:46
这文章应该对新生有所帮助。
4 o6 ~" p$ v  m6 Z4 ^1 a: n楼主能有针对性的发贴非常好啊。+ `3 K; O3 G( u
不过，现在新生好像都还没有电脑吧。没见有你的同学来帮你顶贴哦$ r/ K. i1 M- T% x! z5 o
fxbaobao 发表于 2009-10-16 08:23

/ U% W0 C, N" f, J" n                               
登录/注册后可看大图

  ?9 t9 G8 Z- @" ?  K: K( A都还没带电脑来，他们又不喜欢上网吧多少，所有就.....
作者: 镜中花    时间: 2009-10-23 22:19
真的吗，试一试才行！
作者: 怀念    时间: 2009-10-24 23:48
重头再次学习............
作者: 随缘追梦    时间: 2009-10-27 09:15
很不错的学习方法~~~~~~
7 d0 m" J% A! j1 f让我们少走了，很多弯路啊！！！！
作者: 冷枫    时间: 2009-10-27 09:31
也许对于我来说，学习编程的有效方法，打兴奋剂，要不我会睡着~
作者: 玄冰    时间: 2009-10-28 17:57
新生很多都是贵族，买电脑不会太晚。现在我发现09的有许多已经有电脑了！！
作者: chnzw520    时间: 2009-10-30 22:56
也许对于我来说，学习编程的有效方法，打兴奋剂，要不我会睡着~( {0 V$ W9 o: s3 v4 Z
冷枫 发表于 2009-10-27 09:31
; P* s0 G, v9 m, Z8 H
                               
登录/注册后可看大图

: a/ C$ {" y9 F6 f$ O用不着那东西 只要旁边有个美女在就行了
作者: Forever丨哓四    时间: 2009-11-8 00:40
难吖  C语言  最难就系巨喇
作者: zxc77    时间: 2009-11-9 13:00
新生学得呢么快？学好了你们要帮我编程！！6 I" n; C! ^( {  d, }/ j
Photoby 发表于 2009-10-20 14:07
8 F9 t4 q1 c/ e' u; n$ s" N
                               
登录/注册后可看大图
# B8 ]7 M  X! o1 _. G2 ~
不错，很好的学习方法..................



欢迎光临 广西经贸职业技术学院论坛 (http://gxjmbbs.com/) Powered by Discuz! X3.2