Thứ Ba, 30 tháng 9, 2014

kiểm tra số nguyên tố trong lập trình c

viết chương trình c nhập vào 1 số bất kì và kiểm tra xem nó có phải là số nguyên tố không

///chương trình kiểm tra 1 số có phải là sô nguyên tó không
#include<stdio.h>
#include<conio.h>
void kiemtrasonguyento(int n);
/// là số nguyên tố nếu nó không chia hết cho bất cứ số nào ngoài 1 và chính nó
void main()
{
int n;
printf("nhap so: ");
scanf_s("%d", &n);
kiemtrasonguyento(n);
_getch();
}
void kiemtrasonguyento(int n)
{
int dem = 0;
for (int i = 2; i < n; i++)if (n%i == 0) dem++;
if (dem == 0) printf("la so nguyen to");
else printf("khong phai la so nguyen to");
}

Thứ Hai, 29 tháng 9, 2014

tính tổng các chữ số của 1 số nguyên bất kì nhập từ bàn phím trong lập trình c

tính tổng các chữ số của 1 số nguyên bất kì nhập từ bàn phím trong lập trình c

#include"stdio.h"
#include"conio.h"
void main()
{
int s=0, n;
printf("nhap so nguyen: ");
scanf_s("%d", &n);
while (n % 10 != 0)
{
s += n % 10;
n /= 10;
}
printf("tong cac chu so la: %d", s);
_getch();
}
hình ảnh trong chương trình tính tổng các chữ số của 1 sô nguyen trong lập trình c

úng dụng lệnh if xếp loại học tập trong lập trình c

úng dụng lệnh if xếp loại học tập trong lập trình c

#include"stdio.h"
#include"conio.h"
void main()
{
///nhập điểm các môn
float toan, ly, hoa, dtb;
printf("nhap diem: toan ly hoa\n");
scanf_s("%f%f%f", &toan, &ly, &hoa);
///tính điểm trung bình
dtb = (toan + ly + hoa) / 3;
///dùng lệnh if để xếp loại
if (dtb >= 9)printf("xuat sac");
else if (dtb >= 8) printf("gioi");
else if (dtb >= 7) printf("kha");
else if (dtb >= 5) printf("trung binh");
else printf("kem");
_getch();
}

Chủ Nhật, 28 tháng 9, 2014

giải hệ phương trình bật nhất n ẩn trong lập trình c


///chương trình c giải hệ phương trình bất nhất với số ẩn bất kì, n ẩn
#include<stdio.h>
#include<conio.h>
void nhap(float a[][100], float b[], int n)
{
printf("_______________________________________________\n");
for (int i = 0; i < n; i++)
{
printf("nhap cac he so phuong trinh %d:\n", i + 1);
for (int j = 0; j < n; j++)
scanf_s("%f", &a[i][j]);
scanf_s("%f", &b[i]);
}
printf("_______________________________________________\n");
}
float det(float a[][100], int n)
{
int i, j, k, dem = 0,kt=0;
float b[100], c[100], h, kq=1;
for (i = 0; i < n - 1; i++)
{
if (a[i][i] == 0)
{
for (j = 0; j < n; j++)
if (a[i][j] != 0)
{
for (k = 0; k < n; k++)
{
c[k] = a[k][i];
a[k][i] = a[k][j];
a[k][j] = c[k];
}
dem++;
kt++;
break;
}
if (kt == 0) return 0;
}
b[i] = a[i][i];
for (j = 0; j < n; j++) a[i][j] = a[i][j] / b[i];
for (j = i + 1; j < n; j++)
{
h = a[j][i];
for (k = 0; k < n; k++) a[j][k] = a[j][k] - h*a[i][k];
}

}
b[n - 1] = a[n - 1][n - 1];
for (i = 0; i < n; i++) kq *= b[i];
if (dem % 2 == 0) return kq; else return -kq;
}
void truyen(float a[][100], float b[][100], int n)
{
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
b[i][j] = a[i][j];
}
void gan(float b[100], float a[100][100], int n, int m)
{
for (int i = 0; i < n; i++)
a[i][m] = b[i];
}
void main()
{
printf("___________Tran_Khanh_Toan__________________\n");
printf("_______________________________________________\n");
float dd;
float a[100][100], b[100], x[100], c[100][100];
int n, i;
printf(">>ban muon giai he phuong trinh bat nhat may an ? :");
scanf_s("%d", &n);
nhap(a, b, n);
truyen(a, c, n);
dd = det(c, n);
if (dd!=0)
{
for (i = 0; i < n; i++)
{
truyen(a, c, n);
gan(b, c, n, i);
x[i] = det(c, n);
}
printf("he phuong trinh co nghiem la:\n");
for (i = 0; i < n; i++)
printf("x%d = %.2f\n", i + 1, x[i]);
}
else printf(">>he phuong trinh vo nghiem hoac vo so nghiem");
_getch();
}

Thứ Bảy, 27 tháng 9, 2014

tính định thức ma trận cấp n trong lập trình C


/// tính định thức ma trận vuông bất kì
#include<stdio.h>
#include<conio.h>
/// hàm nhập ma trận
void nhap(float a[][100], int n)
{
printf("_________________________________________________________\n");
for (int i = 0; i < n; i++)
{
printf("nhap hang %d:\n", i + 1);
for (int j = 0; j < n; j++)
scanf_s("%f", &a[i][j]);
}
printf("_______________________________________________________\n");
}
///hàm xuất ma trận
void xuat(float a[][100], int n)
{
printf("_______________________________________________________\n");
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
printf("%8.2f   ", a[i][j]);
}
printf("\n");
}
printf("_________________________________________________________\n");
}
///hàm tính ma trận
float tinh(float a[][100], int n)
{
///khai báo biến và mảng
int i, j, k, dem = 0,kt=0;
float b[100], c[100], h, det = 1;
for (i = 0; i < n - 1; i++)
{
///nếu số ở đường chéo chính =0 thì biến đổi để mất số 0 đó đi
if (a[i][i] == 0)
{
///tìm 1 số khác không trên hàng i
for (j = 0; j < n; j++)
if (a[i][j] != 0)
{
///tiến hành đổi chổ 2 cột i và j
for (k = 0; k < n; k++)
{
c[k] = a[k][i];
a[k][i] = a[k][j];
a[k][j] = c[k];
}
///sau khi đổi xong thì đếm số lần đổi và thoát khỏi vòng for,if
dem++;
kt++;
break;
}
if (kt == 0) return 0;

}
///dùng mảng b[i] để lưu lại những số ta đã chia
b[i] = a[i][i];
///tạo số 1 ở dòng i cột i
for (j = 0; j < n; j++) a[i][j] = a[i][j] / b[i];
///tiến hành biến đổi để có các số 0 tạo thành ma trận tam giác
for (j = i + 1; j < n; j++)
{
h = a[j][i];
for (k = 0; k < n; k++) a[j][k] = a[j][k] - h*a[i][k];
}
}
///vì số thứ [n][n] ta không thể biến nó thành số 0 do nó là hàng cuối cùng
b[n - 1] = a[n - 1][n - 1];
///giá trị của định thức là tích các số mà ta đã chia, tức là b[i]
for (i = 0; i < n; i++) det *= b[i];
/// nếu số lần đổi cột là số lẻ thì ta cần thêm dấu trừ vào định thức đã tính ở trên
if (dem % 2 == 0) return det; else return -det;
}
///chương trình chính
void main()
{
float a[100][100];
int n;
printf("nhap cap cua ma tran:\n");
scanf_s("%d", &n);
nhap(a, n);
xuat(a, n);
printf("dinh thuc cua ma tran la: %.2f", tinh(a, n));
_getch();

}




copy xin vui lòng để tên tác giả bài viết và link blog
xin chân thành cảm ơn!

giải hệ phương trình 3 ẩn trong lập trình c

///giải hệ phương trình 3 ẩn trong c
#include<stdio.h>
#include<conio.h>
void main()
{
float a11, a12, a13, a21, a22, a23, a31, a32, a33, b1, b2, b3, x, y, z, d, dx, dy, dz;
printf("nhap cac he so phuong trinh 1:\n");
scanf_s("%f%f%f%f", &a11, &a12, &a13, &b1);
printf("nhap cac he so phuong trinh 2:\n");
scanf_s("%f%f%f%f", &a21, &a22, &a23, &b2);
printf("nhap cac he so phuong trinh 3:\n");
scanf_s("%f%f%f%f", &a31, &a32, &a33, &b3);
d = a11*a22*a33 + a12*a23*a31 + a21*a32*a13 - a13*a22*a31 - a12*a21*a33 - a11*a32*a23;
dx = b1*a22*a33 + a12*a23*b3 + b2*a32*a13 - a13*a22*b3 - a12*b2*a33 - a23*a32*b1;
dy = a11*b2*a33 + b1*a23*a31 + a21*b3*a13 - a13*b2*a31 - b1*a21*a33 - a23*b3*a11;
dz = a11*a22*b3 + a12*b2*a31 + a21*a32*b1 - b1*a22*a31 - a12*a21*b3 - b2*a32*a11;
if (d == 0)
{
if ((dx == 0) && (dy == 0) && (dz == 0))
printf("he vo so nghiem");
else printf("he vo nghiem");
}
else
{
printf("he co nghiem la:\n x=%.2f \n y=%.2f \n z=%.2f", dx / d, dy / d, dz / d);
}
_getch();
}

Thứ Sáu, 26 tháng 9, 2014

kiểm tra năm nhuận trong lập trình c

///kiểm tra năm nhuận trong lập trình c
#include<stdio.h>
#include<conio.h>
void main()
{
int year;
printf("nhap nam:\n");
scanf_s("%d", &year);
if ((year % 400 == 0) | ((year % 4 == 0) && (year % 100 != 0)))
printf("la nam nhan");
else printf("khong  la nam nhuan");
_getch();
}

giải hệ phương tình 2 ẩn trong lập trình c

///giải hệ phương trình 2 ẩn trong lập trình c
#include<stdio.h>
#include<conio.h>
void main()
{
float a1, b1, c1, a2, b2, c2, d, dx, dy;
printf("nhap vao cac he so cua phuong trinh 1:a1,b1,c1\n");
scanf_s("%f%f%f", &a1, &b1, &c1);
printf("nhap vao cac he so cua phuong trih 2:a2,b2,c2 \n");
scanf_s("%f%f%f", &a2, &b2, &c2);
d = a1*b2 - a2*b1;
dx = c1*b2 - c2*b1;
dy = a1*c2 - a2*c1;
if (d == 0)
{
if ((dx == 0) && (dy == 0)) printf("he vo so nghiem");
else printf("he vo nghiem");
}
else
{
printf("x=%.2f\n", dx / d);
printf("y=%.2f\n", dy / d);
}
_getch();

}

tính tiền điện trong lập trinh c

///tính tiền điện trong lập trình c
/*
0->99kwh don gia la 1000d
100->199kwh don gia la 1500d
200kwh tro len don gia la 2500d
*/
#include<stdio.h>
#include<math.h>
void main()
{
int a = 0, b = 0, c = 0, x, t;
printf_s("nhap vao so kwh dien can tinh tien:\n");
scanf_s("%d", &x);
if (x>199)
{
a = 99;
b = 100;
c = x - 199;
}
else if (x>99)
{
a = 99;
b = x - 99;
}
else a = x;
t = 1000 * a + 1500 * b + 2500 * c;
printf_s("so tien can phai tra la:%d d\n", t);
}

tính tổng số có 4 chữ số trong trong lập trình c

/*tính tổng các chữ số của 1 số có 4 chữ số trong lập trình c*/
#include<stdio.h>
#include<conio.h>
void main()
{
int a, b, c, d, m;
printf("nhap vao m co 4 chu so");
scanf_s("%d", &m);
/*phân tích số đó ra và gán vào từng biến*/
a = m / 1000;
b = (m % 1000) / 100;
c = (m % 100) / 10;
d = m % 10;
printf("tong cac chu so cua m la: %d", a + b + c + d);
_getch();
}

đọc 1 số có 4 chữ số trong lập trình c

chương trình đọc một số có 4 chữ số trong lập trình c

#include<stdio.h>
#include<conio.h>
void main()
{
int n,i, a[4];
printf("nhap so co 4 chu so: ");
scanf_s("%d", &n);
if (n > 999 && n < 10000)
{
printf("doc la             : ");
for (i = 0; i < 4; i++)
{
a[i] = n % 10;
n = n / 10;
}
switch (a[3])
{
case 1:printf(" mot "); break;
case 2:printf(" hai "); break;
case 3:printf(" ba "); break;
case 4:printf(" bon "); break;
case 5:printf(" nam "); break;
case 6:printf(" sau "); break;
case 7:printf(" bay "); break;
case 8:printf(" tam "); break;
case 9:printf(" chin "); break;
}
printf(" nghin ");
switch (a[2])
{
case 1:printf(" mot "); break;
case 2:printf(" hai "); break;
case 3:printf(" ba "); break;
case 4:printf(" bon "); break;
case 5:printf(" nam "); break;
case 6:printf(" sau "); break;
case 7:printf(" bay "); break;
case 8:printf(" tam "); break;
case 9:printf(" chin "); break;
case 0:printf(" khong "); break;
}
printf(" tram ");
switch (a[1])
{
case 1:printf(" mot muoi "); break;
case 2:printf(" hai muoi "); break;
case 3:printf(" ba muoi "); break;
case 4:printf(" bon muoi "); break;
case 5:printf(" nam muoi "); break;
case 6:printf(" sau muoi "); break;
case 7:printf(" bay muoi "); break;
case 8:printf(" tam muoi "); break;
case 9:printf(" chin muoi "); break;
case 0:printf(" le "); break;
}
switch (a[0])
{
case 1:printf(" mot \n"); break;
case 2:printf(" hai \n"); break;
case 3:printf(" ba \n"); break;
case 4:printf(" bon \n"); break;
case 5:if (a[1] == 0) printf(" nam \n");
  else printf(" lam \n"); break;
case 6:printf(" sau \n"); break;
case 7:printf(" bay \n"); break;
case 8:printf(" tam \n"); break;
case 9:printf(" chin \n"); break;
}
}
else printf("nhap so khong dung");
_getch();
}

con trỏ trong lập trình C

1.toán tử lấy địa chỉ
trong lập trình c chúng ta cần xác định được con trỏ của ta đang ở đâu trong ct, với bộ nhớ của biến thì ng lập trình c không cần xác định vì trình biên dịch đã làm sẵn điều rắc rối đó cho chúng ta, chúng ta chỉ việc sử dụng toán tử lấy địa chỉ.
Vào thời điểm mà chúng ta khai báo một biến thì nó phải được lưu trữ trong một vị trí cụ thể trong bộ nhớ. Nói chung chúng ta không quyết định nơi nào biến đó được đặt - thật may mắn rằng điều đó đã được làm tự động bởi trình biên dịch và hệ điều hành, nhưng một khi hệ điều hành đã gán một địa chỉ cho biến thì chúng ta có thể muốn biết biến đó được lưu trữ ở đâu
Điều này có thể được thực hiện bằng cách đặt trước tên biến một dấu và (&), có nghĩa là "địa chỉ của". Ví dụ:
test= &tkt;
lệnh sẽ gán biến test là địa chỉ của bien tkt. vì khi ta đặt trước biến dấu & thì nó đã trở thành địa chỉ của biến trong bộ nhớ mà trình biên dich làm sẵn cho ta. gải sử biến tkt có địa chỉ là 1996 trong bộ nhớ thì biến test của chúng ta sẽ có giá trị là 1996 sau khi thưc hiện lệnh trên.
những biến mà nó lưu trữ địa chỉ của biến như biến test ở trên thì được gọi là con trỏ.tiếp theo chúng ta sẽ rõ biến kiểu này được khai báo như thế nào .
2.toán tử tham chiếu (*)
Bằng cách sử dụng con trỏ chúng ta có thể truy xuất trực tiếp đến giá trị được lưu trữ trong biến được trỏ bởi nó bằng cách đặ trước tên biến con trỏ một dấu sao (*) - ở đây có thể được dịch là "giá trị được trỏ bởi". Vì vậy, nếu chúng ta viết:
beth = *ted; 
(chúng ta có thể đọc nó là: "beth bằng giá trị được trỏ bởi ted"
Toán tử lấy địa chỉ (&) Nó được dùng như là một tiền tố của biến và có thể được dịch là "địa chỉ của", vì vậy &variable1 có thể được đọc là "địa chỉ của variable1". 
Nó chỉ ra rằng cái cần được tính toán là nội dung được trỏ bởi biểu thức được coi như là một địa chỉ. Nó có thể được dịch là "giá trị được trỏ bởi".. *mypointer được đọc là "giá trị được trỏ bởi mypointer". 
3. khai báo biến kiểu con trỏ
vì con trỏ có khả năng tham chiếu trực tiếp đến giá trị mà chúng trỏ tới nên cần thiết phải chỉ rõ kiểu dũ liẹu, nào mà một biến con trỏ trỏ tới khai báo nó. Vì vậy, khai báo của một biến con trỏ sẽ có mẫu sau:
type * pointer_name; 
trong đó type là kiểu dữ liệu được trỏ tới, không phải là kiểu của bản thân con trỏ. Ví dụ:
int * number; 
char * character; 
float * greatnumber; 
đó là ba khai báo của con trỏ. Mỗi biến đầu trỏ tới một kiểu dữ liệu khác nhau nhưng cả ba đều là con trỏ và chúng đều chiếm một lượng bộ nhớ như nhau (kích thước của một biến con trỏ tùy thuộc vào hệ điều hành). nhưng dữ liệu mà chúng trỏ tới không chiếm lượng bộ nhớ như nhau, một kiểu int, một kiểu char và cái còn lại kiểu float.
Tôi phải nhấn mạnh lại rằng dấu sao (*) mà chúng ta đặt khi khai báo một con trỏ chỉ có nghĩa rằng: đó là một con trỏ và hoàn toàn không liên quan đến toán tử tham chiếu mà chúng ta đã xem xét trước đó. Đó đơn giản chỉ là hai tác vụ khác nhau được biểu diễn bởi cùng một dấu.ví dụ chương trình cụ thể:
#include<stdio.h>
#include<conio.h>
void main()
{
int * diachi;
int i,n = 10;
diachi = &n;
i = *diachi;
printf(" dia chi:%d    i=%d", diachi,i);
_getch();
}
Để bạn có thể thấy rằng một con trỏ có thể mang một vài giá trị trong cùng một chương trình.Đây là một ví dụ phức tạp hơn một chút:
#include<stdio.h>
#include<conio.h>
void main()
{
int * diachi;
int n = 10;
diachi = &n;
*diachi = 20;
printf("ban dau n=10\n lay dia chi cua bien n roi thay doi gia tri cua dia chi bo nho do, no lam cho gia tri cua bien n thay doi theo\n n=%d", n);
_getch();
}
nói rõ hơn, dùng biến con trỏ lấy địa chỉ của biến n, khi đó ta dùng toán tử tham chiếu *diachi thò ta sẽ được giá trị tại địa chỉ bộ nhớ đó, cũng chính là giá trị của biến n, khi ta thay đỏi giá trị chứa trong *diachi thì nó cũng lam thay đổi giá trị của biến n.
4. con trỏ và mảng
Trong thực tế, tên của một mảng tương đương với địa chỉ phần tử đầu tiên của nó, giống như một con trỏ tương đương với địa chỉ của phần tử đầu tiên mà nó trỏ tới, vì vậy thực tế chúng hoàn toàn như nhau. Ví dụ, cho hai khai báo sau:
int numbers [20]; 
int * p; 
lệnh sau sẽ hợp lệ:
p = numbers; 
Ở đây p và numbers là tương đương và chúng có cũng thuộc tính, sự khác biệt duy nhất là chúng ta có thể gán một giá trị khác cho con trỏ p trong khi numbers luôn trỏ đến phần tử đầu tiên trong số 20 phần tử kiểu int mà nó được định nghĩa với. Vì vậy, không giống như p - đó là một biến con trỏ bình thường, numbers là một con trỏ hằng. Lệnh gán sau đây là không hợp lệ:
numbers = p; 
bởi vì numbers là một mảng (con trỏ hằng) và không có giá trị nào có thể được gán cho các hằng.

Vì con trỏ cũng có mọi tính chất của một biến nên tất cả các biểu thức có con trỏ trong ví dụ dưới đây là hoàn toàn hợp lệ:
#include<stdio.h>
#include<conio.h>
void main()
{
int *p;
int mang[4];
p = mang;
*p = 1;
p++;
*p = 2;
p = &mang[2];  *p = 3;
p += 1;
*p = 4;
for (int i = 0; i < 4; i++)
{
printf("%3d", mang[i]);
}
_getch();
}
5. khởi tạo con trỏ
Khi khai báo con trỏ có thể chúng ta sẽ muốn chỉ định rõ ràng chúng sẽ trỏ tới biến nào,
int number; 
int *tommy = &number; 
là tương đương với:
int number;
 int *tommy; 
tommy = &number; 
Trong một phép gán con trỏ chúng ta phải luôn luôn gán địa chỉ mà nó trỏ tới chứ không phải là giá trị mà nó trỏ tới. Bạn cần phải nhớ rằng khi khai báo một biến con trỏ, dấu sao (*) được dùng để chỉ ra nó là một con trỏ, và hoàn toàn khác với toán tử tham chiếu. Đó là hai toán tử khác nhau mặc dù chúng được viết với cùng một dấu.
char * terry = "hello"; 
trong trường hợp này một khối nhớ tĩnh được dành để chứa "hello" và một con trỏ trỏ tới kí tự đầu tiên của khối nhớ này (đó là kí tự h') được gán cho terry. Nếu "hello" được lưu tại địa chỉ 1702, lệnh khai báo trên có thể được hình dung như thế này:
H
E
L
L
O
1702
1703
1704
1705
1706
cần phải nhắc lại rằng terry mang giá trị 1702 chứ không phải là 'h' hay "hello".  
Biến con trỏ terry trỏ tới một xâu kí tự và nó có thể được sử dụng như là đối với một mảng (hãy nhớ rằng một mảng chỉ đơn thuần là một con trỏ hằng). Ví dụ, nếu chúng ta muốn thay kí tự 'o' bằng một dấu chấm than, chúng ta có thể thực hiện việc đó bằng hai cách: 
terry[4] = '!'; 
*(terry+4) = '!'; 


Thứ Tư, 24 tháng 9, 2014

chương trình c tính tích hai 2 ma trận bất kì


/*chuong trinh c tinh tich hai ma tran bat ki*/
#include<stdio.h>
#include<conio.h>
#define max 100
/*tao ham nhap ma tran*/
void nhap(int mt[max][max],int h,int c)
{
printf("nhap ma tran:\n _____________________________\n");
for (int i = 0; i < h; i++)
{
printf("nhap hang %d:\n",i+1);
for (int j = 0; j < c; j++)
{
scanf_s("%d", &mt[i][j]);
}
printf("\n");
}
}
/*tao ham xuat ma tran*/
void xuat(int mt[max][max], int h, int c)
{
printf("__________________________\n");
for (int i = 0; i < h; i++)
{
for (int j = 0; j < c; j++)
{
printf("%6d", mt[i][j]);
}
printf("\n");
}
}
int mt1[max][max];
int mt2[max][max];
int tich[max][max];
void main()
{
printf("________author: Tran Khanh Toan____________\n___________________________\n");
int h1, h2, c1, c2;
/*nhap ma tran 1*/
printf(">>>ma tran 1\n");
printf("nhap so hang: ");
scanf_s("%d", &h1);
printf("nhap so cot: ");
scanf_s("%d", &c1);
nhap(mt1, h1, c1);
/*nhap ma tran 2*/
printf("\n__________________________________\n >>>ma tran 2\n");
printf("nhap so hang: ");
scanf_s("%d", &h2);
printf("nhap so cot: ");
scanf_s("%d", &c2);
nhap(mt2, h2, c2);
/*kiem tra hai ma colien hop khong
neu khong lien hop thi ket thuc chuong trinh*/
if (c1 != h2)
{
printf("hai ma tran khong lien hop nen khong the tinh tich");
goto kt;
}
/*tinh tich 2 ma tran*/

for (int i = 0; i < h1; i++)
{
for (int j = 0; j < c2; j++)
{
for (int n = 0; n < c1; n++)
{
tich[i][j] += mt1[i][n] * mt2[n][j];
}
}
}
printf("\n ________________________\n tich 2 ma tran do la: \n");
xuat(tich, h1, c2);
kt:;

_getch();
}
/* a(i,1)*b(1,j)+a(i,2)*b(2,j)=c(i,j)    */
file chương trình,>>>>> click to dwnload

Thứ Ba, 23 tháng 9, 2014

chuỗi , xâu ký tự trong c


Trong tất cả các chương trình chúng ta đã thấy cho đến giờ, chúng ta chỉ sử dụng các biến kiểu số, chỉ dùng để biểu diễn các số. Nhưng bên cạnh các biến kiểu số còn có các xâu kí tự, chúng cho phép chúng ta biểu diễn các chuỗi kí tự như là các từ, câu, đoạn văn bản... Cho đến giờ chúng ta mới chỉ dùng chúng dưới dạng hằng chứ chứa quan tâm đến các biến có thể chứa chúng.
Trong C không có kiểu dữ liệu cơ bản để lưu các xâu kí tự. Để có thể thỏa mãn nhu cầu này, người ta sử dụng mảng có kiểu char. Hãy nhớ rằng kiểu dữ liệu này (char) chỉ có thể lưu trữ một kí tự đơn, bởi vậy nó được dùng để tạo ra xâu của các kí tự đơn.
Ví dụ, mảng sau (hay là xâu kí tự):
char ho_ten[20];
có thể lưu một xâu kí tự với độ dài cực đại là 20 kí tự. Bạn có thể tưởng tượng nó như sau:




















Kích thước cực đại này không cần phải luôn luôn dùng đến. ví dụ xâu ho_ten ở trên có thể lưu các từ như "toan" hay "tran khanh toan".. Vì các mảng kí tự có thể lưu các xâu kí tự ngắn hơn độ dài của nó.
chúng ta có thể biểu diễn nó cho dễ hiểu như sau:

T
O
A
N
















T
R
A
N

K
H
A
N
H

T
O
A
N





 1.Khởi tạo các xâu kí tự. 
Vì những xâu kí tự là những mảng bình thường nên chúng cũng như các mảng khác. Ví dụ, nếu chúng ta muốn khởi tạo một xâu kí tự với những giá trị xác định chúng ta có thể làm điều đó tương tự như với các mảng khác: 
char ho_ten[]={'t','o','a','n'};
char ho_ten[]={"toan"};
char ho_ten[]="xau ki tu";
2.các lệnh nhập xuất dữ liệu dùng riêng cho chuỗi, xâu ký tự
  • nhập ký tự vào cho mảng xâu: gets_s(biến kiểu xâu hay tên mảng xâu mà ta đã tạo);
  • xuất ký tự trong mảng xâu ra màn hình: puts(biến kiểu xâu hay tên mảng xâu mà ta đã tạo);
*chú ý: trước khi nhập dữ liệu cho mảng xâu ta nên xóa rác trong bộ nhớ đệm cho đảm bảo an toàn khi viết chương trình, cú pháp như sau: _flushall();
3.ví dụ về khởi tạo, nhập và xuất mảng kiểu xâu ký tự:
#include<stdio.h>
#include<conio.h>
void main()
{
char ho_ten[20];
printf("nhap ho va ten:\n");
_flushall();
gets_s(ho_ten);
puts(ho_ten);
_getch();
}
__________________________________________________

#include<stdio.h>
#include<conio.h>
void main()
{
char ho_ten[] = { "ho va ten" };
puts(ho_ten);
_getch();
}
4.Gán giá trị cho xâu kí tự 
Vì vế trái của một lệnh gán chỉ có thể là một phần tử của mảng chứ không thể là cả mảng, chúng ta có thể gán một xâu kí tự cho một mảng kiểu char sử dụng một phương pháp như sau: 
xau[0]="h";
xau[1]="e";
xau[2]="l";
xau[3]="l";
xau[4]="o";
Nhưng rõ ràng đây không phải là một phương pháp thực tế. Để gán giá trị cho một xâu kí tự, chúng ta có thể sử dụng loạt hàm kiểu strcpy (string copy), hàm này được định nghĩa trong string.h và có thể được gọi như sau: 
strcpy (string1, string2); 
Lệnh này copy nội dung của string2 sang string1. string2 có thể là một mảng, con trỏ hay một hằng xâu kí tự, bởi vậy lệnh sau đây là một cách đúng để gán xâu hằng "Hello" cho mystring: 
strcpy (mystring, "Hello"); 
ví dụ:
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
char ho_ten[20];
strcpy_s(ho_ten, "tran minh an");
puts(ho_ten);
_getch();
}
Để ý rằng chúng ta phải include file <string.h> để có thể sử dụng hàm strcpy., trong visual 2013 thì lệnh strcpy thay thế bằng strcpy_s(...,...);
 chúng ta luôn có thể viết một hàm đơn giản như ganchuoi  để thay cho lệnh strcpy:
#include<stdio.h>
#include<conio.h>
void copy(char st1[], char st2[])
{
int n = 0;
do
{
st1[n] = st2[n];
n++;
} while (st2[n] != 0);
}
void main()
{
char ho_ten[20];
copy(ho_ten, "tran minh dang");
puts(ho_ten);
_getch();
} 
5.Các hàm để thao tác trên chuỗi 
Thư viện cstring (string.h) không chỉ có hàm strcpy mà còn có nhiều hàm khác để thao tác trên chuỗi. Dưới đây là giới thiệu lướt qua của các hàm thông dụng nhất:
char* strcat (char* dest, const char* src); 
Gắn thêm chuỗi src vào phía cuối của dest. Trả về dest. 
int strcmp (const char* string1, const char* string2); 
So sánh hai xâu string1 và string2. Trả về 0 nếu hai xâu là bằng nhau. 
char* strcpy (char* dest, const char* src);
Copy nội dung của src cho dest. Trả về dest.
 size_t strlen (const char* string); 
Trả về độ dài của string. 
Chú ý: char* hoàn toàn tương đương với char[]