CTT003 Ch04 HamVaKyThuatToChucChuongTrinh

Nhp mn lp trnh
ThS. ng Bnh Phng (dbphuong@fit.hcmus.edu.vn)

Gii thiu
Truyn tham s cho hm
Bin ton cc v bin cc b
Cc v d v ng dng hm trong lp trnh
Hm trong chng trnh nhiu tp tin
m ngun
Cc vn tm hiu m rng kin thc
ngh nghip
Thut ng v bi c thm ting Anh
10/7/2013 Khoa CNTT - H Khoa hc t nhin 2

Chng Chng trnh ln
trnh
c chia thnh cc
chng trnh con
Nhp
d liu
X l
Xut
kt qu
nh hn nhm d
dng phn chia v
kim tra cng vic
X l 1 X l 2 hay s dng li
Tip cn top-down
nhng b phn
trong lp trnh cu trc hon tt.
Hm c cc c im sau:
C mt tn duy nht.
L mt thnh phn c lp.
Thc hin mt cng vic c th.
C th nhn cc i s.
C th tr v gi tr cho chng trnh gi n.
Hm
Cc i tng Thc hin Cc kt qu
c sn (i s) mt cng vic
c th no

return-type function_name(param-type param_name,
, param-type param_name);
Trong :
return-type: kiu ca gi tr hm s tr v, nu khng
tr v g c th kiu tr v s l void.
function_name: tn ca hm, th hin cng vic hm
s lm, nn bt u bng mt ng t.
param-name, param-type: tn v kiu tng ng ca
tham s hnh thc (formal parameter).
c kt thc bng du chm phy ;

return-type function_name(param-type param_name,
, param-type param_name)
{
// statements here
}
Trong :
Dng u l tiu hm (ging nguyn mu hm
nhng khng c ; v bt buc phi c tn tham s).
Tip theo l thn hm (t trong {}) cha cc cu
lnh hm s thc hin (phi c t nht mt lnh
return nu kiu tr v khng phi l void)
Hm c sn (trong ngn ng hoc do mt
hng phn mm vit bn hoc cho) nh:
Hm xut, nhp thng tin: printf(), scanf(),
Hm ton hc: sqrt(), pow(), abs(), sin(),
Hm do ngi lp trnh vit thm nh:
Hm xut, nhp thng tin: Nhp s dng, ...
Hm ton hc: Tnh cn bc 3, tnh cn bc n,
tnh giai tha, gii phng trnh bc 1, bc 2,
bc 4 i xng,
void main()
{ i s
int a = 7, b = 5;
float z = 9;
printf(a = %d\n, a);
printf(b = );
scanf(%d, &b);
z = (float)pow((double)b, (double)a);
}
Bin nhn gi tr
tr v ca hm
Hm tnh ( ) cha c trong
3
th vin math.h
3
hm 3
Lu :
0 = 0
3
= (, 1.0 3) > 0
(, 1.0 3) < 0
Khai bo hm: double sqrt3(double x);

double sqrt3(double x) {
double y = 0; // temporary variable
if (x > 0)
y = pow(x, 1/(double)3);
else
if (x < 0)
y = -pow(-x, 1/(double)3);
return y; // returns result
} // end of function

Vit hm tnh ( , )

, hm (nu xc nh)

Lu :
Nu l th
lun xc nh.
0 = 0

= (, 1.0 ) > 0
(, 1.0 ) < 0
Nu chn th ch xc nh khi 0.

= , 1.0/
// Function name : sqrtN
// Description : calculates n-th root of x
// Parameter : double x
// Return type : double
// 0 if n < 0
// 1 if n = 0
// x^(1/n) if n odd
// x^(1/n) if n even and x >= 0
// 0 if n even and x < 0
double sqrtN(double x);

double sqrtN(double x)
{
double y = 0;
if (n <= 0 || (n % 2 ==0 && x < 0))

return 0;
if (n % 2 != 0)
{
if (x > 0)
y = pow(x, 1.0/n);

else // n odd and x <= 0
if (x < 0)
y = -pow(-x, 1.0/n);
}
else // n even and x > 0
y = pow(x, 1.0/n);
return y;
}

Cc cu lnh bn trong hm ch c thc
thi khi hm c gi t mt phn khc
ca chng trnh.
Khi gi hm, chng trnh c th truyn n
hm thng tin di dng mt hay nhiu i s.
main() { f1() { f2() {
call f1 call f2 }
} }

i s (argument) hay tham s thc
(actual parameter) l d liu ca chng
trnh truyn n hm c kiu d liu ng
vi tham s hnh thc c khai bo trong
nguyn mu hm. D liu ny thng
c hm s dng thc hin cng vic
ca n.
i s
2, 3, x
int SolveEq1(double a, double b, double &x);

C hai cch truyn i s
Truyn bng gi tr (pass by value)
i s khng i do hm to bn sao ca i s khi nhn.
Thng thng l d liu c sn.
Tham s hnh thc tng ng c gi l tham tr.
Truyn bng tham chiu (pass by reference): C++
i s c th thay i khi gi hm.
Thng thng l d liu cn tnh ton, xc nh.
Tham s hnh thc tng ng c gi l tham
chiu hay tham bin.
int Inc(int x);
void main() {
int a = 9, b;
b = Inc(a); // a is passed by value
printf(a = %d, b = %d\n, a, b);
}
int Inc(int x) { int x = 9;
x++;
return x;
}

a ch
ca a
int Inc(int &x); // C++ int Inc(int *x); /* C */

void main() { void main() {
int a = 9, b; int a = 9, b;
b = Inc(a); b = Inc(&a);
printf(a = %d, printf(a = %d,
b = %d\n, a, b); b = %d\n, a, b);
} }
int Inc(int &x) { int Inc(int *x) {
x++; (*x)++;
return x; int *x = &a; return (*x);
} }
void f1(double x);
double x = 15.06;
void f2(double &x);
void f3(const double &x);
void main() {
Tn b nh
double a = 15.06; khi x ln
f1(a); // passed by value
f2(a); // passed by reference
f3(a); // passed by const reference
}
// defines f1(), f2(), f3() here

C hai cch gi hm
Mi hm u c th c gi bng cch s
dng tn hm km danh sch cc i s
trong mt cu lnh n. Nu hm c gi tr
tr v, gi tr ny s b b qua.
i vi cc hm c gi tr tr v, do cc hm
ny c quy thnh mt gi tr (do hm tr
v) nn chng l cc biu thc C hp l v c
th c s dng bt k ni u m mt
biu thc C c th c s dng.
void DoSomething();
int Sum(int x, int y);
void main() {
DoSomething();
Sum(1, 2); // the return value is discarded
int x = Sum(1, 2);
int y = Sum(1, Sum(2, 3));
printf(%d\n, Sum(1, 2));
}
// defines DoSomething() and Sum() here

Nu c s dng cc hm c kiu tr v l
void nh mt biu thc th trnh bin dch
s pht sinh mt thng bo li.
void DoSomething();
void main() {
DoSomething();
int x = DoSomething(); // error
printf(%d\n, DoSomething()); // error
}
// defines DoSomething() here
Hy truyn i s vo hm lm cho
hm tng qut c th ti s dng.
int Sum() { // non generic
int x, y;
// inputs x, y here
return x + y;
}
int Sum(int x, int y) { // generic and thus reusable
return x + y;
}
Nn tn dng u im ca kh nng t
hm vo trong biu thc nhng trnh lm
cho cu lnh di dng, kh hiu.
void main() {
int a = 1, b = 2 , c = 3, x;
printf(%d, Sum(a, Sum(b, c))); // !!!
x = Sum(b, c);
printf(%d, Sum(a, x)); // better
}
L phm vi hiu qu ca bin khi c
khai bo trong chng trnh
Bin cc b (local variable)
c khai bo bn trong hm.
Ch c tc dng trong hm .
c khi to bi mt hng s hoc mt biu
thc tng ng vi kiu ca bin.
Bin cc b s b xa khi b nh ngay khi
kt thc hm.
Bin ton cc (global variable)
c khai bo bn ngoi tt c cc hm (k
c hm main()).
C tc dng trn ton b chng trnh(!).
c khi to mt ln duy nht bi mt hng
s tng ng vi kiu ca n trc khi c
s dng bn trong cc hm (t ng c gn
gi tr 0 nu khng khi gn tng minh).
Ch c gii phng khi kt thc chng trnh.

Bin ton cc Bin cc b
int x = 999; void f();
void f(); void main() {
void main() { int x = 999;
printf(%d\n, x); printf(%d\n, x);
f(); f();
} }
void f() { void f() {
printf(%d\n, x); printf(%d\n, x);
} }

int x = 1, y = 2;
void f() {
int x = 3;
printf(x = %d, y = %d\n, x, y);
if (y > 0) {
int z = 4;
printf(%d\n, z);
}
printf(x = %d\n, x);
printf(z = %d\n, z); // error
}
Bin ton cc (global variable) l cch gi
khc ca bin ngoi (external variable).
Ni ng ra, tm vc ca bin ngoi (hay
bin ton cc) l trong ton b m ngun
ca tp tin cha khai bo bin .
Cc chng trnh C c kch thc khng ln
ch c cha trong mt tp tin m ngun
nn tm vc l ton b chng trnh.
Bin ngoi c khai bo tng minh bng
t kha extern.
int x = 999; // external/global variable
void f();
void main() {
extern int x;
printf(%d\n, x);
C th b t kha extern
f(); nu trong cng
} mt tp tin m ngun
void f() {
extern int x;
printf(%d\n, x);
}
Hn ch s dng bin ngoi/ton cc v iu ny
ph v tnh c lp n th (modular
independence), nguyn l trung tm ca lp tnh
cu trc.
c lp n th l tng mi hm hay n th
trong mt chng trnh cha tt c m ngun v
d liu cn thit thc hin cng vic ca n.
i vi cc chng trnh nh th vic s dng
chung bin ngoi/ton cc khng quan trng
nhng khi lm vic vi cc chng trnh ln hn
v phc tp hn th s qu rng buc vo bin
ngoi s ny sinh nhiu vn rc ri.

Mi khi chng trnh thc thi li khai bo
bin cc b, mt bn sao ring bit ca
bin cc b c to ra.
Nu bin cc b c khai bo l tnh
(static) th bin ny s c to ra mt ln
duy nht ln u tin khi chng trnh
thc thi li khai bo ca n.
Khng nh bin ton cc, bin cc b tnh
khng b truy cp v thay i bi cc hm khc.
void f() {
static int n = 0; // initialized once
int x = 0; // initialized n times
printf(n = %d, x = %d\n, n++, x++);
}
n = 0, x = 0
void main() { n = 0, x = 1
n = 0, x = 2
int i;
for (i = 0; i < 3; i++)
f();
}
C 3 loi d liu sau khi thc hin yu cu
gi hm:
D liu nhp: d liu c sn, cn thit thc
hin hm, thng c truyn dng tham tr
hoc tham bin.
D liu xut: d liu hm tnh ton c, thng
c tr v bng lnh return hoc dng tham
bin.
D liu trung gian: d liu do hm to ra trong
qu trnh thc hin cng vic, thng phc v
cho vic tnh ton d liu xut.

// returns f(x, y) = ax + by and reverses the signs of a, b if f < 0
int Calculate(float &a, float &b, float x, float y) {
int temp1, temp2, f;
temp1 = a * x;
temp2 = b * y;
f = temp1 + temp2;
if (f < 0) { D liu nhp?
a = -a; D liu trung gian?
b = -b; D liu xut?
}
return f;
}

Vit chng trnh gii phng trnh bc 1:
+ = 0 ,
Cch 1: Vit trc tip ngay trong hm main()
(nhp a, b ri xt tng trng hp in ra
kt qu). Cch ny khng th dng li sau
ny khi cn gii phng trnh bc nht.
Cch 2: Vit mt hm nhim v gii phng
trnh bc 1, hm c s dng li trong
chng trnh chnh.

, hm 1 ,
Khai bo hm:
int SolveEq1(float a, float b, float &x);
Lu : s nghim nSol khng thy trong
khai bo hm s c tnh ton v ghi vo
bin tm ri tr v bi lnh return.
nh ngha cc hng s c bit:
#define VODINH -1

int SolveEq1(float a, float b, float &x) {
int nSol = 0;
if (a != 0) {
x = -b/a;
nSol = 1;
}
else
if (b == 0)
nSol = VODINH;
return nSol;
}
void main() {
float a, b, x;
// inputs a, b here
int nSol = SolveEq1(a, b, x);

switch (nSol) {
// checks nSol here
}
}

Vit hm gii phng trnh bc 2:
2 + + = 0
, , hm 2 1 , 2 ,
Khai bo hm:
int SolveEq2(float a, float b, float c, float &x1, float &x2);

int SolveEq2(float a, float b, float c, float &x1, float &x2) {
int nSol = 0;
float delta;
if (a == 0)
return SolveEq1(a, b, x1); // reuses SolveEq1()
delta = b*b 4*a*c;

if (delta < 0)
return 0;

if (delta == 0) {
x1 = x2 = -b/(2*a);
nSol = 1;
}
else { // delta > 0
x1 = (-b sqrt(delta))/(2*a);
x2 = (-b + sqrt(delta))/(2*a);
nSol = 2;
}
return nSol;
}
void main() {
float a, b, c, x1, x2;
// inputs a, b, c here
int nSol = SolveEq2(a, b, c, x1, x2);

switch (nSol) {
// checks nSol here
}
}

Gii phng trnh:
4 + 3 + 2 + + = 0
, , hm 4 1, 2, 3, 4,
Khai bo hm:
int SolveEq4Sym(float a, float b, float c,
float &x1, float &x2, float &x3, float &x4);

Nu = 0 th phng trnh thnh:
( 2 + + ) = 0
Do :
=0
2 + + = 0
Dng li hm SolveEq2() vit gii
phng trnh bc 2: 2 + + = 0

Nu 0 th do = 0 khng phi l
nghim nn ta c bin i tng ng:
1 1
2 + 2 + + + =0

1 1
t = +
2 = 2 +
2
+2
Phng trnh tr thnh:
2 2 + + = 0
2 + + 2 = 0

Dng hm gii phng trnh
SolveEq2()
2 + + 2 = 0 tm nghim .
tm , s dng hm SolveEq2()
TH1. V nghim Phng trnh ban u v
nghim.
TH2. C 1 nghim 1 : gi SolveEq2() gii:
2 1 + 1 = 0
TH3. C 2 nghim 1 , 2 : tng t TH2.

int SolveEq4Sym(float a, float b, float c,
float &x1, float &x2, float &x3, float &x4)
{
int nSol;
if (a == 0) {
x1 = 0;
nSol = SolveEq2(b, c, b, x2, x3);
if (nSol != VODINH)
nSol++;
}

else {
float Y1, Y2;
int nSol1 = SolveEq2(a, b, c-2*a, Y1, Y2);
switch (nSol1) {
case 0:
nSol = 0;
break;
case 1:
nSol = SolveEq2(1, -Y1, 1, x1, x2);
break;

case 2:
int nSol2 = SolveEq2(1, -Y1, 1, x1, x2);
switch (nSol2) {
case 0:
nSol = SolveEq2(1, -Y2, 1,
x1, x2);
break;
case 1:
x2, x3);
break;
case 2:
x3, x4);
break;
}
break;
}
}
return nSol;
}

Chng trnh vi mt tp tin m ngun ch
ph hp vi cc chng trnh nh.
Khi t mt tp cc hm c mc ch tng
qut vo mt tp tin ring, ta c th s dng
li cc hm ny cc chng trnh khc.
Khi vit chng trnh gm nhiu tp tin m
ngun, mi tp tin m ngun c gi l mt
n th (module). Cch lp trnh nh vy gi
l lp trnh n th (modular programming),
c lin quan rt gn vi lp trnh cu trc.
Mi chng trnh C ch c duy nht mt
hm main().
n th cha hm main() c gi l n
th chnh, cc n th khc c gi l
n th ph.
Mt tp tin tiu ring r thng c
i km vi mi n th ph.

/* mymath.h: header file for mymath.c */
double sqrt3(double x);
double sqrtN(double x);
/* end of mymath.h */
/* mymath.c: module containing math functions */

#include mymath.h
double sqrt3(double x) { /* statements */ }
double sqrtN(double x) { /* statements */ }
/* end of mymath.c */
#include <stdio.h>
#include mymath.h
void main() {
int x;
printf(Enter an integer value: );
scanf(%d, &x);
printf(The 3rd root of %d is %.lf\n,
x, sqrt3((double)x);
/* other statements here */
}

Hm v bin ton cc (hay bin ngoi)
khng t ng c thy trong cc n
th khc.
Khai bo cc n th khc c th thy
c hm hay bin ton cc trong cc
n th khc:
Hm: s dng ch th #include (v d trc)
Bin ton cc: s dng t kha extern

/* main module: sample.c */
int x = 99, y; /* the compiler automatically initializes y to 0 */
void main() {/* statements */ }
/* secondary module: mod1.c */

extern int x, y;
void func1() { /* statements */ }
/* secondary module: mod2.c */

extern int x;
void func2() { /* statements */ }
Nhu cu
Thc hin mt cng vic vi nhiu cch khc
nhau. Nu cc hm khc tn s kh nh.
V d:
Cc hm tnh tr tuyt i trong C (math.h)
int abs(int n);
long labs(long n);
double fabs(double n);
Cc hm tnh cn bc 2: sqrt(), sqrtf()
Khi nim
L cc hm cng tn nhng c tham s u
vo hoc kiu tr v khc nhau nhm cho
php ngi dng chn cch thun li nht
thc hin cng vic.
Nguyn mu hm khi b tn tham s phi
khc nhau.
Vic s dng cc hm trng tn c gi l
np chng hay qu ti (overload) hm.

// prints integers from 1 to n
void PrintIntegers(int n);
// prints integers from x to y

void PrintIntegers(int x, int y);
// prints integers from x to y

// with an arithmetic progression a
void PrintIntegers(int x, int y, int a);

Cc hm sau y l nh nhau do cng
nguyn mu hm: int Sum(int, int);
// calculates a + b
int Sum(int a, int b);
// calculates b + a
int Sum(int b, int a);
// calculates x + y
float f(float x) { return x/2; }
double f(double x) { return x/2; }
void main() {
float x = 29.12;
double y = 17.06;
printf(%.2f\n, f(x)); // float
printf(%.2lf\n, f(y)); // double
printf(%.2f\n, f(10)); // ???
printf(%.2f\n, f((float)10)); // float
}
void f(unsigned char c) { printf(%d, c); }
void f(char c) { printf(%c, c); }
void main()
{
f(A); // char
f(65); // ???
f((char)65); // char
f((unsigned char)65); // unsigned char
}

int f(int a, int b) { return a + b; }
int f(int a, int &b) { return a + b; }
void main()
{
int x = 1, y = 2;
printf(%d, f(x, 2)); // b = 2
printf(%d, f(x, y)); // ???
}

int f(int a) { return a*a; }
int f(int a, int b = 1) { return a*b; }
void main()
{
printf(%d\n, f(2912, 1706));
printf(%d\n, f(2912)); // ???
}

Khi nim
L hm c mt hay nhiu tham s hnh thc
c gn sn gi tr mc nh. Cc tham s
ny nhn gi tr mc nh nu khng c
i s tng ng c truyn vo.
Cc tham s mc nh phi c dn v tn
cng bn phi.
V d
void PrintFraction(int num, int denom = 1);

Lu :
Mun truyn i s khc thay cho i s mc
nh, phi truyn i s thay cho cc i s
mc nh trc n.
V d:
void SolveEq2(int a, int b = 0, int c = 0);
Gii phng trnh: 2 2 + 0 + 3 = 0
Sai: SolveEq2(2, 3); // a=2, b=3, c=0
ng: SolveEq2(2, 0, 3); // a=2, b=0, c=3
Lu :
Nu = thng xuyn xy ra th nn chuyn
thnh tham s c i s mc nh l .
V d, = 0 (Nam), = 18.
Nu = v = thng xuyn xy ra
nhng = thng xuyn hn th nn t
tham s mc nh sau .
V d, trong cng lp hc = 18 xy ra
nhiu hn = 0 do nn t sau
.
Khi nim
Hm c th truyn vo hm khc di dng
i s u vo.
Vic khai bo tham s l hm tng t nh
khai bo nguyn mu hm (khng cn tn
cc tham s hnh thc)
Ch c php truyn cc hm c nguyn
mu hm (sau khi b i tn cc tham s hnh
thc) ging vi nguyn mu hm ca tham s
hnh thc hm c khai bo.
int FindBestNumber(int a, int b, int Better(int, int)) {
int numBest = a;
if (Better(b, a)) {
numBest = b;
}
return numBest;
}
int MaxNumber(int x, int y) { return x > y; }
int MinNumber(int x, int y) { return x < y; }

int FindBestNumber(int a[], int n, int Better(int, int)) {
int i, idBest = 0;
for (i = 1; i < n; i++) {
if (Better(a[i], a[idBest]))
idBest = id;
}
return a[idBest];
}
int MaxNumber(int x, int y) { return x > y; }
int MinNumber(int x, int y) { return x < y; }

Khi nim
qui ch mt tnh hung m trong hm
gi chnh n theo cch trc tip hay gin tip.
V d
Tnh giai tha: ! = ( 1) 2 1
Do ( 1) 2 1 = ( 1)! ! = ( 1)
Tng t ( 1)! = ()! ( 1)
Tip tc cho n khi tnh 1! ta c ngay kt
qu l 1, th ngc li tnh c !
Khai bo hm:
unsigned int factorial(unsigned int n);
nh ngha hm:
unsigned int factorial(unsigned int n)
{
if (n == 1)
return 1;
else
return n * factorial(n 1);
}
Tiu ch so snh/Ngn ng C C++ C# Java
Khai bo hm c lp vi

cc thnh phn khc
Khai bo hm (phng thc)

trong lp i tng (class)
Truyn bng gi tr

(tham tr) (kiu c s)
Truyn bng a ch

Truyn bng bin
(s dng t (i tng
(tham bin/tham chiu) (s dng &)
kha ref, out) v mng)
Tham s c gi tr mc nh
Hm trng tn

(np chng hm)

function: hm (chng trnh con)
structured programming: lp trnh cu trc
modular programming: lp trnh n th
parameter: tham s
argument : i s
formal parameter: tham s hnh thc, tng ng vi
parameter
actual parameter: tham s thc, tng ng vi argument
function prototype: nguyn mu hm
function header: tiu hm
function declaration: khai bo hm
function definition: nh ngha hm

local variable: bin cc b
extern varialbe: bin ngoi
global variable: bin ton cc, tng t extern variable
call by value: truyn i s bng gi tr (tham tr)
call by reference: truyn i s bng tham bin
(tham chiu)
scope: tm vc, phm vi hiu qu
recursion: s qui
overload: np chng, qu ti
ambiguity: nhp nhng, m h

Bradley L. Jones and Peter Aitken, Teach
Yourself C in 21 days, 6th Edition, SAMS, 2003.
Day 5. Packaging Code in Functions, pp. 97-122.
Day 12. Understanding Variable Scope, pp. 285-303.
Day 21. Advanced Compiler Use Programming with
Multiple Source-Code Files, pp. 593-600.
Bjarne Stroustrup, The C++ Programming
Language, 3rd Edition, AT&T, 1997.
Chapter 7. Functions, pp. 143-164.
Chapter 9. Source Files and Programs, pp. 197-220.

CTT003 Ch04 HamVaKyThuatToChucChuongTrinh

Uploaded by

Copyright:

Available Formats

You might also like

CTT003 Ch04 HamVaKyThuatToChucChuongTrinh

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CTT003 Ch04 HamVaKyThuatToChucChuongTrinh

Uploaded by

Copyright:

Available Formats

Nhp mn lp trnh

ThS. ng Bnh Phng (dbphuong@fit.hcmus.edu.vn)

10/7/2013 Khoa CNTT - H Khoa hc t nhin 2

10/7/2013 Khoa CNTT - H Khoa hc t nhin 5

10/7/2013 Khoa CNTT - H Khoa hc t nhin 6

Khai bo hm: double sqrt3(double x);

10/7/2013 Khoa CNTT - H Khoa hc t nhin 10

10/7/2013 Khoa CNTT - H Khoa hc t nhin 11

10/7/2013 Khoa CNTT - H Khoa hc t nhin 13

if (n <= 0 || (n % 2 ==0 && x < 0))

10/7/2013 Khoa CNTT - H Khoa hc t nhin 14

10/7/2013 Khoa CNTT - H Khoa hc t nhin 15

10/7/2013 Khoa CNTT - H Khoa hc t nhin 17

int SolveEq1(double a, double b, double &x);

10/7/2013 Khoa CNTT - H Khoa hc t nhin 20

int Inc(int &x); // C++ int Inc(int *x); /* C */

10/7/2013 Khoa CNTT - H Khoa hc t nhin 22

10/7/2013 Khoa CNTT - H Khoa hc t nhin 24

10/7/2013 Khoa CNTT - H Khoa hc t nhin 30

10/7/2013 Khoa CNTT - H Khoa hc t nhin 31

10/7/2013 Khoa CNTT - H Khoa hc t nhin 35

10/7/2013 Khoa CNTT - H Khoa hc t nhin 38

10/7/2013 Khoa CNTT - H Khoa hc t nhin 39

10/7/2013 Khoa CNTT - H Khoa hc t nhin 41

10/7/2013 Khoa CNTT - H Khoa hc t nhin 42

int nSol = SolveEq1(a, b, x);

10/7/2013 Khoa CNTT - H Khoa hc t nhin 44

10/7/2013 Khoa CNTT - H Khoa hc t nhin 45

delta = b*b 4*a*c;

10/7/2013 Khoa CNTT - H Khoa hc t nhin 46

int nSol = SolveEq2(a, b, c, x1, x2);

10/7/2013 Khoa CNTT - H Khoa hc t nhin 48

10/7/2013 Khoa CNTT - H Khoa hc t nhin 49

10/7/2013 Khoa CNTT - H Khoa hc t nhin 50

10/7/2013 Khoa CNTT - H Khoa hc t nhin 51

10/7/2013 Khoa CNTT - H Khoa hc t nhin 52

10/7/2013 Khoa CNTT - H Khoa hc t nhin 53

10/7/2013 Khoa CNTT - H Khoa hc t nhin 54

10/7/2013 Khoa CNTT - H Khoa hc t nhin 56

10/7/2013 Khoa CNTT - H Khoa hc t nhin 59

/* mymath.c: module containing math functions */

10/7/2013 Khoa CNTT - H Khoa hc t nhin 61

10/7/2013 Khoa CNTT - H Khoa hc t nhin 62

/* secondary module: mod1.c */

/* secondary module: mod2.c */

10/7/2013 Khoa CNTT - H Khoa hc t nhin 66

// prints integers from x to y

// prints integers from x to y

10/7/2013 Khoa CNTT - H Khoa hc t nhin 67

10/7/2013 Khoa CNTT - H Khoa hc t nhin 70

10/7/2013 Khoa CNTT - H Khoa hc t nhin 71

10/7/2013 Khoa CNTT - H Khoa hc t nhin 72

10/7/2013 Khoa CNTT - H Khoa hc t nhin 73

10/7/2013 Khoa CNTT - H Khoa hc t nhin 77

10/7/2013 Khoa CNTT - H Khoa hc t nhin 78

10/7/2013 Khoa CNTT - H Khoa hc t nhin 81

10/7/2013 Khoa CNTT - H Khoa hc t nhin 83

10/7/2013 Khoa CNTT - H Khoa hc t nhin 84

int Inc(int &x); // C++ int Inc(int x); / C */

delta = bb 4a*c;