Chương 3: Mảng và con trỏ ppt

CHƯƠNG 3: Mảng và con trỏ

1. Mảng

Mảng (Array)

Là một tập các vị trí nhớ liên tiếp nhau

Các phần tử trong mảng có cùng tên và cùng
kiểu.

Truy nhập tới phần tử trong mảng

Xác định thông qua tên mảng và chỉ số:
arrayname[ position number ]

Phần tử đầu tiên ở vị trí thứ 0

Khai báo mảng

type arrayName
[
arraySize
];
int c[ 10 ]; // mảng c gồm 10 số nguyên
float d[ 3284 ]; // mảng d gồm 3284 số thực

Có thể khai báo nhiều mảng cùng kiểu
int b[ 100 ], x[ 27 ];

Khởi tạo mảng

Sử dụng vòng lặp for: gán giá trị cho từng phần tử
trong mảng.

Sử dụng danh sách khởi tạo:
int n[ 5 ] = { 1, 2, 3, 4, 5 };

Nếu không đủ giá trị khởi tạo thì những phần tử còn lại sẽ
nhận giá trị mặc định.

Nếu giá trị khởi tạo nhiều hơn kích thước mảng thì sẽ báo
lỗi.

Gán tất cả các phần tử với cùng một giá trị
int n[ 5 ] = { 0 };

Nếu kích thước mảng không được khai báo thì danh sách
khởi tạo sẽ xác định:
int n[] = { 1, 2, 3, 4, 5 };
//Mảng n có 5 phần tử

Tham số mảng

Tham số mảng được biểu diễn bởi kiểu dữ liệu và kích thước
của mảng
void display(float [n][m]);

Hàm có thể không cần biết kích thước của mảng nhưng phải
biết kích thước của một phần tử trong mảng

void myFunction(int n[]);
void display(float [][m]);

Khi gọi hàm, ta chỉ cần truyền tên mảng
int myArray[ 24 ];
myFunction( myArray);

Mảng được truyền theo kiểu truyền tham chiếu

Hàm có thể chỉnh sửa dữ liệu của các phần tử trong mảng

Tên mảng là địa chỉ của phần tử đầu tiên

Ví dụ về tham số mảng
#include <iostream>
using namespace std;
void printarray (int arg[], int length)
{
for (int n=0; n<length; n++)
cout << arg[n] << " ";
cout << "\n";
}
int main ()
{
int firstarray[] = {5, 10, 15};
int secondarray[] = {2, 4, 6, 8, 10};
printarray (firstarray,3);
printarray (secondarray,5);
return 0;
}

Mảng nhiều chiều

Mảng nhiều chiều được coi là mảng của mảng.

Khai báo:
double sales[2][2];
sales[1][0]=2.5;

Khởi tạo:
double sales[2][2]={{1.2,3.0},{-1.0,2.3}};

Xâu ký tự

Là một mảng các ký tự

Tất cả các xâu ký tự đều kết thúc với ký tự null ('\0')

Ví dụ

char string1[] = "hello";

Ký tự null được tự động bổ sung.

string1 có 6 ký tự

char string1[] =
{'h', 'e', 'l', 'l','o', '\0’ };

Kiểu dữ liệu string


string là một lớp chuẩn trong C++

Các ký tự trong string được đánh từ 0

Khởi tạo một biến kiểu string như sau:

string s1 (“Man”);

string s2=“Beast”;

string s3;

Ta có thể sử dụng các tóan tử tóan học, logic … trên
đối tượng string

s3 = s1;

s3 = “Neither” + s1 + “nor”;

s3 += s2;

string và toán tử >>

Hàm getline(cin, string str): lưu thông tin từ luồng vào chuẩn đưa vào str.

Ví dụ:
string full_name;
cout<< “Enter your fullname:”;
getline(cin, full_name);

// full_name lưu thông tin mà người sử dụng nhập từ bàn phím

2. Con trỏ

Mỗi biến trong chương trình chiếm một vùng
nhớ, ví dụ biến kiểu int chiếm 4 byte nhớ.

Vị trí của vùng nhớ được gọi là địa chỉ của
biến
10101011
00001111
10001000
11100011
0x1054
0x1055
0x1056
0x1057
00111011
0x1058
10111100
0x1059
11001100
0x1060
int i; Địa chỉ của i
char c; Địa chỉ của c
short s; Địa chỉ của s

Biến con trỏ

Biến con trỏ là biến lưu giá trị của địa chỉ

vùng nhớ.

Mỗi kiểu dữ liệu có một biến con trỏ riêng:
con trỏ kiểu int, con trỏ kiểu char…

C++ sử dụng:

Toán tử & để lấy địa chỉ của biến

Toán tử * để lấy nội dung của biến được trỏ.

Ví dụ:
int i=17;
int* ptr; // khai báo biến trỏ kiểu int
ptr= &i; // gán địa chỉ của biến i cho con trỏ ptr
cout << *ptr << endl; // hiển thị nội dung của biến i

Biến con trỏ …
17
0x1054
int i;
int* ptr;
ptr=&i;
Đ
ị
a

c
h
ỉ

cout << *ptr << endl;
N
ộ
i

d
u
n
g

Biến con trỏ …
int v; // khai báo biến v kiểu int
int w; // khai báo biến w kiểu int
int* p; // khai báo biến p kiểu con trỏ trỏ tới kiểu int
p=&v;
// gán địa chỉ của v cho con trỏ p
v=3;
// gán giá trị 3 cho v
*p=7;
// gán giá trị 7 cho v
p=&w;
// gán địa chỉ của w cho con trỏ p
*p=12;
// gán giá trị 12 cho w

Con trỏ hằng

Khai báo hằng:
const int result = 5; // result là hằng
result = 10; // sau đó gán lại giá trị thì C++ sẽ báo lỗi


Khai báo con trỏ hằng:
const char* answer_ptr = "Forty-Two";
// answer_ptr là con trỏ trỏ tới hằng kiểu char

Dữ liệu được trỏ bởi con trỏ hằng thì không
thể thay đổi nhưng con trỏ thì có thể.
answer_ptr = "Fifty-One"; // đúng (answer_ptr là biến con trỏ)
*answer_ptr = 'X'; // sai (*answer_ptr là hằng)

Con trỏ hằng …

Nếu khai báo:
char *const nameptr = "Test"; //name_ptr là con trỏ hằng
nameptr = "New"; // sai (name_ptr là hằng)
*nameptr = 'B'; // đúng (*nameptr là char)

Nếu khai báo như sau thì không thể thay đổi được cả con trỏ và nội dung của con trỏ:
const char* const titleptr = "Title";

Con trỏ và mảng

Mảng có thể được truy nhập thông qua con
trỏ.

Tên mảng là một con trỏ hằng trỏ tới kiểu dữ
liệu của các thành phần được lưu trữ trong
mảng.
int array[5] = { 23, 5, 12, 34, 17 };
// sử dụng chỉ số để truy nhập tới các phần tử của mảng

for (int i=0; i< 5; i++)
cout << array[i] << endl;
// sử dụng con trỏ để truy nhập tới các phần tử của mảng
for (int i=0; i< 5; i++)
cout << *(array+i) << endl;

Ví dụ về: Con trỏ và mảng
#include <iostream>
using namespace std;
int main ()
{
int numbers[5];
int * p;
p = numbers; *p = 10;
p++; *p = 20;
p = &numbers[2]; *p = 30;
p = numbers + 3; *p = 40;
p = numbers; *(p+4) = 50;
for (int n=0; n<5; n++)
cout << numbers[n] << ", ";
return 0;
}

Con trỏ là tham số của hàm

C++ cung cấp 3 cách truyền tham số:

Truyền tham trị: void f(int x);

Truyền tham chiếu: void f(int& x);


Truyền con trỏ: void f(int* x);

Con trỏ là tham số của hàm …
void swap( double& x, double& y)
{
double tmp=x;
x=y;
y=tmp;
}
void swap( double* ptr1, double* ptr2)
{
double tmp=*ptr1;
*ptr1=*ptr2;
*ptr2=tmp;
}
double a=3.0;
double b=5.0
swap(a,b); // gọi tham chiếu của biến a và b
swap(&a, &b); // sử dụng địa chỉ của biến a và b

Con trỏ là tham số của hàm…
void bsort (double* ptr, int n)
{
int j,k;
for (j=0; j<n-1; j++)
for(k=j+1; k<n; k++)
if(*(ptr+j) > *(ptr+k))
swap(ptr+j,ptr+k);
}

double array[6] = { 2.3, 4.5, 1.2, 6.8, 0.8, 4.9 };
bsort(array,n);

Phép toán học trên con trỏ

Phân biệt các phép toán trên biến con trỏ và biến thông thường.
char *mychar;
short *myshort;
long *mylong;
mychar++;
myshort++;
mylong++;

Con trỏ trỏ đến con trỏ
char a;
char * b;
char ** c;
a = 'z';
b = &a;
c = &b;

Con trỏ void

Con trỏ void có thể lưu địa chỉ của biến có kiểu dữ liệu bất kỳ.
#include <iostream>
using namespace std;
void increase (void* data, int psize)
{
if ( psize == sizeof(char) )
{ char* pchar; pchar=(char*)data; ++(*pchar); }

else if (psize == sizeof(int) )
{ int* pint; pint=(int*)data; ++(*pint); }
}
int main ()
{
char a = 'x';
int b = 1602;
increase (&a,sizeof(a));
increase (&b,sizeof(b));
cout << a << ", " << b << endl;
return 0;
}

Con trỏ null

Con trỏ có giá trị null tức là không trỏ vào một địa chỉ nhớ cụ thể nào.