Bài 3 : Mảng Và Con Trỏ Trong Lập Trình C++

8144

Chương 3 : mảng và con trỏ trong c++

Chúng ta sẽ tiếp tục bài học về lập trình hướng đối tượng c++ qua bài chương 3 : mảng và con trỏ trong c++

 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ụ :  

#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”;
  • 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

con-tro-c2

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

bien-con-tro-c2

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)
  • 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ụ :

#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);
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
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++;

toan-c-2

Con trỏ đến con trỏ

char a;
char * b;
char ** c;
a = 'z';
b = &a;
c = &b

con-tro-con tro-2

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.

Con trỏ hàm

  • Thường được sử dụng để truyền hàm như một tham số của hàm khác.
  • Khi khai báo tham số là con trỏ hàm cần khai báo:
    • Prototype của hàm
    • Không sử dụng tên hàm
    • Đặt dấu * trước tên tham số

Ví dụ :

#include <iostream>
using namespace std;

int addition (int a, int b)
{ return (a+b); }

int subtraction (int a, int b)
{ return (a-b); }

int operation (int x, int y, int *functocall)(int,int))
{
	int g;
	g = (*functocall)(x,y);
	return (g);
}

int main ()
{
	int m,n;
	int (*minus)(int,int) = subtraction;
	m = operation (7, 5, addition);
	n = operation (20, m, minus);
	cout <<n;
	return 0;
}

Bộ nhớ động

  • Cấp phát bộ nhớ trong khi thực thi chương trình
  • Toán tử new: cấp phát bộ nhớ
    • pointer = new type
    • pointer = new type [number_of_elements]
  • Toán tử delete: xóa vùng nhớ đã cấp
    • delete pointer;
    • delete [] pointer;

Ví dụ : 

#include <iostream>
using namespace std;
int main ()
{
	int i,n;  int * p;
	cout << "How many numbers would you like to type? ";	cin >> i;
	p= new int[i];
	if (p == 0)
		cout << "Error: memory could not be allocated";
	else
	{
		for (n=0; n<i; n++)
		{
			cout << "Enter number: ";
			cin >> p[n];
		}
		cout << "You have entered: ";
		for (n=0; n<i; n++)
			cout << p[n] << ", ";
		delete[] p;
	}
	return 0;
}

Như vậy là chúng ta lại tìm hiểu thêm về mảng và con trỏ trong lập trình c++ , để hiểu rõ hơn các bạn có thể tìm và đọc lại bài mảng trong ccon trỏ trong c để tăng thêm lượng kiến thức.

Nguồn : lập trình c

Rating: 5.0. From 1 vote.
Please wait...

BÌNH LUẬN