Giáo trình "Ngôn ngữ lập trình C"

ịch phát hiện lỗi khi gọi hàm hay tự động việc chuyển dạng.
	Nguyên mẫu của hàm thực chất là dòng đầu tiên của hàm thêm vào dấu ;. Tuy nhiên trong nguyên mẫu có thể bỏ tên các đối.
	Hàm thường có một vài đối. Ví dụ như hàm max3s có ba đối là a,b,c. cả ba đối này đều có giá trị float. Tuy nhiên, cũng có hàm không đối như hàm main.
	Hàm thường cho ta một giá trị nào đó. Lẽ dĩ nhiên giá trị của hàm phụ thuộc vào giá trị các đối.
6.2. Hàm không cho các giá trị : 
	Các hàm không cho giá trị giống như thủ tục ( procedure ) trong ngôn ngữ lập trình PASCAL. Trong trường hợp này, kiểu của nó là void.
	Ví dụ hàm tìm giá trị max trong ba số là max3s ở trên có thể được viết thành thủ tục hiển thị số cực đại trong ba số như sau :
	void htmax3s(float a, float b, float c)
	{
	float max;
	max=a;
	if (max<b) max=b;
	if (max<c) max=c;
	}
	Lúc này, trong hàm main ta gọi hàm htmax3s bằng câu lệnh :
	htmax3s(x,y,z);
6.3. Hàm đệ qui :
6.3.3. Mở đầu :
	C không những cho phép từ hàm này gọi tới hàm khác, mà nó còn cho phép từ một điểm trong thân của một hàm gọi tới chính hàm đó. Hàm như vậy gọi là hàm đệ qui.
	Khi hàm gọi đệ qui đến chính nó, thì mỗi lần gọi máy sẽ tạo ra một tập các biến cục bộ mới hoàn toàn độc lập với tập các biến cục bộ đã được tạo ra trong các lần gọi trước.
	Để minh hoạ chi tiết những điều trên, ta xét một ví dụ về tính giai thừa của số nguyên dương n. Khi không dùng phương pháp đệ qui hàm có thể được viết như sau :
	long int gt(int n) /* Tính n! với n>=0*/
	 {
	long int gtphu=1;
	int i;
	for (i=1;i<=n;++i)
	gtphu*=i;
	return s;
	 }
	Ta nhận thấy rằng n! có thể tính theo công thức truy hồi sau :
	n!=1	nếu n=0
	n!=n*(n-1)!	nếu n>0
Hàm tính n! theo phương pháp đệ qui có thể được viết như sau :
	long int gtdq(int n)
	 {
	if (n==0 || n==1)
	 return 1;
	else
	 return(n*gtdq(n-1));
 	 }
Ta đi giải thích hoạt động của hàm đệ qui khi sử dụng trong hàm main dưới đây :
#include "stdio.h"
main()
	{
	printf("\n 3!=%d",gtdq(3));
	}
	Lần gọi đầu tiên tới hàm gtdq được thực hiện từ hàm main(). Máy sẽ tạo ra một tập các biến tự động của hàm gtdq. Tập này chỉ gồm các đối n. Ta gọi đối n được tạo ra lần thứ nhất là n thứ nhất. Giá trị của tham số thực ( số 3 ) được gán cho n thứ nhất. Lúc này biến n trong thân hàm được xem là n thứ nhất. Do n thứ nhất có giá trị bằng 3 nên điều kiện trong toán tử if là sai và do đó máy sẽ lựa chọn câu lệnh else. Theo câu lệnh này, máy sẽ tính giá trị biểu thức :
	n*gtdq(n-1) (*)
	Để tính biểu thức trên, máy cần gọi chính hàm gtdq vì thế lần gọi thứ hai sẽ thực hiện. Máy sẽ tạo ra đối n mới, ta gọi đó là n thứ hai. Giá trị của n-1 ở đây lại là đối của hàm , được truyền cho hàm và hiểu là n thứ hai, do vậy n thứ hai có giá trị là 2. Bây giờ, do n thứ hai vẫn chưa thoả mãn điều kiện if nên máy lại tiếp tục tính biểu thức :
	n*gtdq(n-1) (**)
	Biểu thức trên lại gọi hàm gtdq lần thứ ba. Máy lại tạo ra đối n lần thứ ba và ở đây n thứ ba có giá trị bằng 1. Đối n=1 thứ ba lại được truyền cho hàm, lúc này điều kiện trong lệnh if được thoả mãn, máy đi thực hiện câu lệnh :
	return 1=gtdq(1) (***)
	Bắt đầu từ đây, máy sẽ thực hiện ba lần ra khỏi hàm gtdq. Lần ra khỏi hàm thứ nhất ứng với lần vào thứ ba. Kết quả là đối n thứ ba được giải phóng, hàm gtdq(1) cho giá trị là 1 và máy trở về xét giá trị biểu thức
	n*gtdq(1) đây là kết quả của (**)
ở đây, n là n thứ hai và có giá trị bằng 2. Theo câu lệnh return, máy sẽ thực hiện lần ra khỏi hàm lần thứ hai, đối n thứ hai sẽ được giải phóng, kết quả là biểu thức trong (**) có giá trị là 2.1. Sau đó máy trở về biểu thức (*) lúc này là :
	n*gtdq(2)=n*2*1
n lại hiểu là thứ nhất, nó có giá trị bằng 3, do vậy giá trị của biểu thức trong (*) là 3.2.1=6. Chính giá trị này được sử dụng trong câu lệnh printf của hàm main() nên kết quả in ra trên màn hình là :
	3!=6
Chú ý :
	Hàm đệ qui so với hàm có thể dùng vòng lặp thì đơn giản hơn, tuy nhiên với máy tính khi dùng hàm đệ qui sẽ dùng nhiều bộ nhớ trên ngăn xếp và có thể dẫn đến tràn ngăn xếp. Vì vậy khi gặp một bài toán mà có thể có cách giải lặp ( không dùng đệ qui ) thì ta nên dùng cách lặp này. Song vẫn tồn tại những bài toán chỉ có thể giải bằng đệ qui.
6.3.2. Các bài toán có thể dùng đệ qui :
	Phương pháp đệ qui thường áp dụng cho các bài toán phụ thuộc tham số có hai đặc điểm sau :
	Bài toán dễ dàng giải quyết trong một số trường hợp riêng ứng với các giá trị đặc biệt của tham số. Người ta thường gọi là trường hợp suy biến.
	Trong trường hợp tổng quát, bài toán có thể qui về một bài toán cùng dạng nhưng giá trị tham số thì bị thay đổi. Sau một số hữu hạn bước biến đổi dệ qui nó sẽ dẫn tới trường hợp suy biến.
	Bài toán tính n giai thừa nêu trên thể hiện rõ nét đặc điểu này.
6.3.3. Cách xây dựng hàm đệ qui :
	Hàm đệ qui thường được xây dựng theo thuật toán sau :	
	 if ( trường hợp suy biến)
	{
	Trình bày cách giải bài toán khi suy biến
	}
	 else /* Trường hợp tổng quát */
	{
	Gọi đệ qui tới hàm ( đang viết ) với các giá
	trị khác của tham số
	}
6.3.4. Các ví dụ về dùng hàm đệ qui :
Ví dụ 1 : 
	Bài toán dùng đệ qui tìm USCLN của hai số nguyên dương a và b.
	Trong trường hợp suy biến, khi a=b thì USCLN của a và b chính là giá trị của chúng.
	Trong trường hợp chung :
	uscln(a,b)=uscln(a-b,b) nếu a>b
	uscln(a,b)=uscln(a,b-a) nếu a<b
Ta có thể viết chương trình như sau :
#include "stdio.h"	
int uscln(int a,int b ); /* Nguyên mẫu hàm*/
main()
	{ int m,n;
	printf("\n Nhap cac gia tri cua a va b :");
	scanf("%d%d",&m,&n);
	printf("\n USCLN cua a=%d va b=%d la :%d",m,m,uscln(m,n))
	}
int uscln(int a,int b)
	{	
	if (a==b) 
	return a;
	else
	 if (a>b)
	return uscln(a-b,b);
	 else 
	return uscln(a,b-a);
	}
Ví dụ 2 :	
Chương trình đọc vào một số rồi in nó ra dưới dạng các ký tự liên tiếp.
# include "stdio.h"
# include "conio.h"
void prind(int n);
main()
{ 
 int a;
 clrscr();
 printf("n=");
 scanf("%d",&a);
 prind(a);
 getch();
}
void prind(int n)
 { 
 int i;
 if (n<0)
 { putchar('-');
 n=-n;
 }
 if ((i=n/10)!=0)
 prind(i);
 putchar(n%10+'0');
 }
6.4. Bộ tiền sử lý C :
	C đưa ra một số cách mở rộng ngôn ngữ bằng các bộ tiền sử lý macro đơn giản. Có hai cách mở rộng chính là #define mà ta đã học và khả năng bao hàm nội dung của các file khác vào file đang được dịch.
Bao hàm file :	
	Để dễ dàng xử lý một tập các #define và khai báo ( trong các đối tượng khác ), C đưa ra cách bao hàm các file khác vào file đang dịch có dạng :
#include "tên file"
Dòng khai báo trên sẽ được thay thế bởi nội dung của file có tên là tên file. Thông thường có vài dòng như vậy xuất hiện tại đầu mỗi file gốc để gọi vào các câu lệnh #define chung và các khai báo cho các biến ngoài. Các #include được phép lồng nhau. Thường thì các #include được dùng nhiều trong các chương trình lớn, nó đảm bảo rằng mọi file gốc đều được cung cấp cùng các định nghĩa và khai báo biến, do vậy tránh được các lỗi khó chịu do việc thiếu các khai báo định nghĩa. Tất nhiên khi thay đổi file được bao hàm vào thì mọi file phụ thuộc vào nó đều phải dịch lại.
Phép thế MACRO :
	Định nghĩa có dạng :
#define biểu thức 1 [ biểu thức 2 ]
sẽ gọi tới một macro để thay thế biểu thức 2 (nếu có) cho biểu thức 1.
Ví dụ :
#define YES 1
	Macro thay biến YES bởi giá trị 1 có nghĩa là hễ có chỗ nào trong chương trình có xuất hiện biến YES thì nó sẽ được thay bởi giá trị 1.
	Phạm vi cho tên được định nghĩa bởi #define là từ điểm định nghĩa đến cuối file gốc. Có thể định nghĩa lại tên và một định nghĩa có thể sử dụng các định nghĩa khác trước đó. Phép thế không thực hiện cho các xâu dấu nháy, ví dụ như YES là tên được định nghĩa thì không có việc thay thế nào được thực hiện trong đoạn lệnh có "YES".
	Vì việc thiết lập #define là một bước chuẩn bị chứ không phải là một phần của chương trình biên dịch nên có rất ít hạn chế về văn phạm về việc phải định nghĩa cái gì. Chẳng hạn như những người lập trình ưa thích PASCAL có thể định nghĩa :
	#define then
	#define begin {
	#define end; }
sau đó viết đoạn chương trình :
	if (i>0)	 then
	begin
	a=i;
	......
	end;
Ta cũng có thể định nghĩa các macro có đối, do vậy văn bản thay thế sẽ phụ thuộc vào cách gọi tới macro.
Ví dụ :
	 Định nghĩa macro gọi max như sau :
	#define max(a,b) ((a)>(b) ?(a):(b))	
Việc sử dụng :
	x=max(p+q,r+s);
tương đương với :
	x=((p+q)>(r+s) ? (p+q):(r+s));
Như vậy ta có thể có hàm tính cực đại viết trên một dòng. Chừng nào các đối còn giữ được tính nhất quán thì macro này vẫn có giá trị với mọi kiểu dữ liệu, không cần phải có các loại hàm max khác cho các kiểu dữ liệu khác nhưng vẫn phải có đối cho các hàm.
Tất nhiên nếu ta kiểm tra lại việc mở rộng của hàm max trên, ta sẽ thấy rằng nó có thể gây ra số bẫy. Biểu thức đã được tính lại hai lần và điều này là không tốt nếu nó gây ra hiệu quả phụ kiểu như các lời gọi hàm và toán tử tăng. Cần phải thận trọng dùng thêm dấu ngoặc để đảm bảo trật tự tính toán. Tuy vậy, macro vẫn rất có giá trị.
Chú ý : 
	Không được viết dấu cách giữa tên macro với dấu mở ngoặc bao quanh danh sách đối.
Ví dụ :
	Xét chương trình sau :
main()
	{
	int x,y,z;
	x=5;
	y=10*5;
	z=x+y;
	z=x+y+6;
	z=5*x+y;
	z=5*(x+y);
	z=5*((x)+(y));
	printf("Z=%d",z);
	getch();
	return;
	}	
Chương trình sử dụng MACRO sẽ như sau :
#define BEGIN {
#define END }
#define INTEGER int
#define NB 10
#define LIMIT NB*5
#define SUMXY x+y
#define SUM1 (x+y)
#define SUM2 ((x)+(y))
main()
	BEGIN
	INTEGER x,y,z;
	x=5;
	y=LIMIT;
	z=SUMXY;
	z=5*SUMXY;
	z=5*SUM1;
	z=5*SUM2;
	printf("\n Z=%d",z);
	getch();
	return;
	END
Chương 7
Con trỏ
	Con trỏ là biến chứa địa chỉ của một biến khác. Con trỏ được sử dụng rất nhiều trong C, một phần là do chúng đôi khi là cách duy nhất để biểu diễn tính toán, và phần nữa do chúng thường làm cho chương trình ngắn gọn và có hiệu quả hơn các cách khác .
	Con trỏ đã từng bị coi như có hại chẳng kém gì lệnh goto do cách sử dụng chúng đã tạo ra các chương trình khó hiểu. Điều này chắc chắn là đúng khi người ta sử dụng chúng một cách lôn xộn và do đó tạo ra các con trỏ trỏ đến đâu đó không biết trước được.
7.1. Con trỏ và địa chỉ :
	Vì con trỏ chứa địa chỉ của đối tượng nên nó có thể xâm nhập vào đối tượng gián tiếp qua con trỏ. Giả sử x là một biến kiểu int, và giả sử px là con trỏ được tạo ra theo một cách nào đó. 
Phép toán một ngôi & sẽ cho địa chỉ của đối tượng, nên câu lệnh :
px=&x;
sẽ gán địa chỉ của biến x cho trỏ px, và px bây giờ được gọi là " trỏ tới biến x ". Phép toán & chỉ áp dụng được cho các biến và phần tử bảng, kết cấu kiểu &(x+1) và &3 là không hợp lệ. Lấy đại chỉ của biến register cũng là sai.
	Phép toán một ngôi * coi là toán hạng của nó là đại chỉ cần xét và thâm nhập tới địa chỉ đó để lấy ra nội dung. Nếu biến y có kiểu int thì thì lệnh :
y=*px;
sẽ gán giá trị của biến mà trỏ px trỏ tới. Vậy dãy lệnh :
	px=&x;
	y=*px;
sẽ gán giá trị của x cho y như trong lệnh : 
	y=x;
Các khai báo cho các biến con trỏ có dạng :
	tên kiểu *tên con trỏ
Ví dụ :
 Như trong ví dụ trên, ta khai báo con trỏ px kiểu int :	
	int *px;
Trong khai báo trên ta đã ngụ ý nói rằng đó là một cách tượng trưng, rằng tổ hợp *px có kiểu int, tức là nếu px xuất hiện trong ngữ cảnh *px thì nó cũng tương đương với biến có kiểu int.
	Con trỏ có thể xuất hiện trong các biểu thức. Chẳng hạn, nếu px trỏ tới số nguyên x thì *px có thể xuất hiện trong bất kỳ ngữ cảnh nào mà x có thể xuất hiện. 
Ví dụ :
Lệnh	y=*px+1; 
sẽ đặt y lớn hơn x một đơn vị.
Lệnh printf("%d",*px); 
sẽ in ra giá trị hiện tại của x
Lệnh :
 d=sqrt((double) *px); 
sẽ gán cho biến d căn bậc hai của x, giá trị này bị buộc phải chuyển sang double trước khi được chuyền cho sqrt ( cách dùng hàm sqrt ).
	Trong các biểu thức kiểu như :
	y=*px+1;
phép toán một ngôi * và & có mức ưu tiên cao hơn các phép toán số học, cho nên biểu thức này lấy bất ký giá trị nào mà px trỏ tới, cộng với 1 rồi gán cho y.
	Con trỏ cũng có thể xuất hiện bên vế trái của phép gán. Nếu px trỏ tới x thì sau lệnh :
	*px=0;
x sẽ có giá trị bằng 0. Cũng tương tự các lệnh:
	*px+=1;
	(*px)++;
sẽ tăng giá trị của x lên 1 dơn vị.
	Các dấu ngoặc đơn ở câu lệnh cuối là cần thiết , nếu không thì biểu thức sẽ tăng px thay cho tăng ở biến mà nó trỏ tới vì phép toán một ngôi như * và ++ được tính từ phải sang trái.
	Cuối cùng, vì con trỏ là biến nên ta có thao tác chúng như đối với các biến khác. Nếu py cũng là con trỏ int thì lệnh :
	py=px;
sẽ sao nội dung của px vào py, nghĩa là làm cho py trỏ tới nơi mà px trỏ.
7.2. Con trỏ và mảng một chiều :
	Trong C có mối quan hệ chặt chẽ giữa con trỏ và mảng : các phần tử của mảng có thể được xác định nhờ chỉ số hoặc thông qua con trỏ.
7.2.1.Phép toán lấy địa chỉ :
	Phép toán này chỉ áp dụng cho các phần tử của mảng một chiều. Giả sử ta có khai báo :
	double b[20];
Khi đó phép toán :
	&b[9]	
sẽ cho địa chỉ của phần tử b[9].
7.2.2. Tên mảng là một hằng địa chỉ :
	Khi khai báo :
	float a[10];
máy sẽ bố trí bố trí cho mảng a mười khoảng nhớ liên tiếp, mỗi khoảng nhớ là 4 byte. Như vậy, nếu biết địa chỉ của một phần tử nào đó của mảng a, thì ta có thể dễ dàng suy ra địa chỉ của các phần tử khác của mảng.
	Với C ta có :
	a tương đương với &a[0]
	a+i tương đương với &a[i]
	*(a+i) tương đương với a[i]
7.2.3. Con trỏ trỏ tới các phần tử của mảng một chiều :
	Khi con trỏ pa trỏ tới phần tử a[k] thì :
	pa+i trỏ tới phần tử thứ i sau a[k], có nghĩa là nó trỏ tới a[k+i].
	pa-i trỏ tới phần tử thứ i trước a[k], có nghĩa là nó trỏ tới a[k-i].
	*(pa+i) tương đương với pa[i].
Như vậy, sau hai câu lệnh :
	float a[20],*p;
	p=a;
thì bốn cách viết sau có tác dụng như nhau :
	a[i] *(a+i) p[i] *(p+i)
Ví dụ :
	Vào số liệu của các phần tử của một mảng và tính tổng của chúng :
Cách 1:
#include "stdio.h"
main()
	{
	float a[4],tong;
	int i;
	for (i=0;i<4;++i)
	 {
 	printf("\n a[%d]=",i);
	scanf("%f",a+i);
	 }
	tong=0;
	for (i=0;i<4;++i)
	tong+=a[i];
	printf("\n Tong cac phan tu mang la :%8.2f ",tong);
	}
Cách 2 :
#include "stdio.h"
main()
	{
	float a[4],tong, *troa;
	int i;
	troa=a;
	for (i=0;i<4;++i)
	 {
 	printf("\n a[%d]=",i);
	scanf("%f",&troa[i]);
	 }
	tong=0;
	for (i=0;i<4;++i)
	tong+=troa[i];
	printf("\n Tong cac phan tu mang la :%8.2f ",tong);
	}
Cách 3 :
#include "stdio.h"
main()
	{
	float a[4],tong,*troa;
	int i;
	troa=a;
	for (i=0;i<4;++i)
	 {
 	printf("\n a[%d]=",i);
	scanf("%f",troa+i);
	 }
	tong=0;
	for (i=0;i<4;++i)
	tong+=*(troa+i);
	printf("\n Tong cac phan tu mang la :%8.2f ",tong);
	}
Chú ý :
	Mảng một chiều và con trỏ tương ứng phải cùng kiểu.
7.2.4. Mảng, con trỏ và xâu ký tự :
	Như ta đã biết trước đây, xâu ký tự là một dãy ký tự đặt trong hai dấu nháy kép, ví dụ như :
	"Viet nam"
	Khi gặp một xâu ký tự, máy sẽ cấp phát một khoảng nhớ cho một mảng kiểu char đủ lớn để chứa các ký tự của xâu và chứa thêm ký tự '\0' là ký tự dùng làm ký tự kết thúc của một xâu ký tự. Mỗi ký tự của xâu được chứa trong một phần tử của mảng.
	Cũng giống như tên mảng, xâu ký tự là một hàng địa chỉ biểu thị địa chỉ đầu của mảng chứa nó. Vì vậy nếu ta khai báo biến xau như một con trỏ kiểu char :
	char *xau;
thì phép gán :
	xau="Ha noi"
là hoàn toàn có nghĩa. Sau khi thực hiện câu lệnh này trong con trỏ xau sẽ có địa chỉ đầu của mảng (kiểu char) đang chứa xâu ký tự bên phải. Khi đó các câu lệnh :
	puts("Ha noi");
	puts(xau);
sẽ có cùng một tác dụng là cho hiện lên màn hình dòng chữ Ha noi.
	Mảng kiểu char thường dùng để chứa một dãy ký tự đọc vào bộ nhớ. Ví dụ, để nạp từ bàn phím tên của một người ta dùng một mảng kiểu char với độ dài 25, ta sử dụng các câu lệnh sau :
	char ten[25];
	printf("\n Ho ten :");
	gets(ten);
	Bây giờ ta xem giữa mảng kiểu char và con trỏ kiểu char có những gì giống và khác nhau. Để thấy được sự khác nhau của chúng, ta đưa ra sự so sánh sau : 
	char *xau, ten[15];
	ten="Ha noi"
	gets(xau);
Các câu lệnh trên là không hợp lệ. Câu lệnh thứ hai sai ở chỗ : ten là một hằng địa chỉ và ta không thể gán một hằng địa chỉ này cho một hằng địa chỉ khác. Câu lệnh thứ ba không thực hiện được, mục đích của câu lệnh là đọc từ bàn phím một dãy ký tự và lưu vào một vùng nhớ mà con trỏ xau trỏ tới. Song nội dung của con trỏ xau còn chưa xác định. Nếu trỏ xau đã trỏ tới một vùng nhớ nào đó thì câu lệnh này hoàn toàn có ý nghĩa. Chẳng hạn như sau khi thực hiện câu lệnh :
	xau=ten;
thì cách viết : 
gets(ten) ; và gets(xau);
đều có tác dụng như nhau.
7.3. Con trỏ và mảng nhiều chiều :
	Việc sử lý mảng nhiều chiều phức tạp hơn so với mảng một chiều. Không phải mọi qui tắc đúng với mảng một chiều đều có thể áp dụng cho mảng nhiều chiều.
7.3.1.Phép lấy địa chỉ :
	Phép lấy địa chỉ đối với các phần tử mảng hai chiều chỉ có thể áp dụng khi các phần tử mảng hai chiều có kiểu nguyên, còn lại thì phép lấy địa chỉ cho các phần tử mảng nhiều chiều là không thực hiện được .Ví dụ như ta có thể lấy địa chỉ &a[1][2] khi a là mảng nguyên.
Thủ thuật đọc từ bàn phím phần tử mảng hai chiều dùng lệnh scanf :
	Chương trình đọc vào số liệu cho một ma trận hai chiều sẽ được thực hiện thông qua việc đọc vào một biến trung gian, đọc một giá trị và chứa tạm vào một biến trung gian sau đó ta gán biến cho phần tử mảng: 
	#include "stdio.h"
	main()
	 {
	float a[2][3], tg;
	int i,j;
	for (i=0;i<2;++i)
	for (j=0;j<2;++j)
	 {
	printf("\n a[%d][%d]=",i,j);
	scanf("%8.2f",&tg);
	a[i][j]=tg;
	 }
	 }
7.3.2. Phép cộng địa chỉ trong mảng hai chiều:
	Giả sử ta có mảng hai chiều a[2][3] có 6 phần tử úng với sáu địa chỉ liên tiếp trong bộ nhớ được xếp theo thứ tự sau :
Phần tử
a[0][0]
a[0][1]
a[0][2]
a[1][0]
a[1][1]
a[1][2]
Địa chỉ
1
2
3
4
5
6
Tên mảng a biểu thị địa chỉ đầu tiên của mảng. Phép cộng địa chỉ ở đây được thực hiện như sau :
	C coi mảng hai chiều là mảng ( một chiều ) của mảng, như vậy khai báo 
	float a[2][3];
thì a là mảng mà mỗi phần tử của nó là một dãy 3 số thực ( một hàng của mảng ). 
Vì vậy :
	a trỏ phần tử thứ nhất của mảng : phần tử a[0][0]
	a+1 trỏ phần tử đầu hàng thứ hai của mảng : phần tử a[1][0]
	........
7.3.3. Con trỏ và mảng hai chiều :
	Để lần lượt duyệt trên các phần tử của mảng hai chiều ta có thể dùng con trỏ như minh hoạ ở ví dụ sau :
float *pa,a[2][3];
pa=(float*)a;
lúc đó :
pa trỏ tới a[0][0]
pa+1 trỏ tới a[0][1]
pa+2 trỏ tới a[0][2]
pa+3 trỏ tới a[1][0]
pa+4 trỏ tới a[1][1]
pa+5 trỏ tới a[1][2]
Ví dụ :
	Dùng con trỏ để vào số liệu cho mảng hai chiều.
Cách 1 :
#include "stdio.h"
main()
	{
	float a[2][3],*pa;
	int i;
	pa=(float*)a;
	for (i=0;i<6;++i)
	scanf("%f",pa+i);
	}
Cách 2 :
#include "stdio.h"
main()
	{
	float a[2][3],*pa;
	int i;
	for (i=0;i<6;++i)
	scanf("%f",(float*)a+i);
	}
7.4. Kiểu con trỏ, kiểu địa chỉ, các phép toán trên con trỏ :
7.4.1. Kiểu con trỏ và kiểu địa chỉ :
	Con trỏ dùng để lưu địa chỉ. Mỗi kiểu địa chỉ cần có kiểu con trỏ tương ứng. Phép gán địa chỉ cho con trỏ chỉ có thể thực hiện được khi kiểu địa chỉ phù hợp với kiểu con trỏ. 
Ví dụ theo khai báo :
	float a[20][30],*pa,(*pm)[30];
thì :
pa là con trỏ float
pm là con trỏ kiểu float [30]
a là địa chỉ kiểu float [30]
Vì thế phép gán :
	pa=a;
là không hợp lệ. Nhưng phép gán :
	pm=a;
7.4.2. Các phép toán trên con trỏ:
	Có 4 phép toán liên quan đến con trỏ và đại chỉ là : 
	Phép gán.
	Phép tăng giảm địa chỉ.
	Phép truy cập bộ nhớ.
	Phép so sánh.
Phép gán :
	Phép gán chỉ thực hiện với các con trỏ cùng kiểu. Muốn gán các con trỏ khác kiểu phải dùng phép ép kiểu như ví dụ sau :
	int x;
	char *pc;
	pc=(char*)(&x);
Phép tăng giảm địa chỉ :
	Để minh hoạ chi tiết cho phép toán này, ta xét ví dụ sau :
Các câu lệnh :
	float x[30],*px;
	px=&x[10];
cho con trỏ px là con trỏ float trỏ tới phần tử x[10]. Kiểu địa chỉ float là kiểu địa chỉ 4 byte, nên các phép tăng giảm địa chỉ được thực hiện trên 4 byte. Vì thế :
	px+i trỏ tới phần tử x[10+i]
	px-i trỏ tới phần tử x[10-i]
Xét ví dụ khác :
Giả sử ta khai báo :
	float b[40][50];
Khai báo trên cho ta một m