Netcut Full mới nhất – Cắt mạng máy tính khác trong LAN và cách chống NET Cut

Khi bạn gặp trường hợp sử dụng máy tính ở một mạng Lan mà co khá nhiều máy tính khác tham gia vào, bỗng nhiên bạn bị ngắt kết nối Internet mà không rõ lý do trong khi máy khác ở trong mạng Lan đó vẫn sử dụng Internet bình thường ???

 Lúc này, bạn sẽ phải kiểm tra lại các chế độ cài đặt Internet và dải DNS xem có lỗi gì không. Tuy nhiên nếu những điều đó chắc chắn không có lỗi gì thì bạn cần nghĩ tới trường hợp đó là có một ai đó dùng cùng mạng Lan đã chơi xấu bạn bằng phần mềm NET cut – Phần mềm có tính năng ngắt kết nối internet của máy tính bất kỳ ở trong cùng mạng Lan. Phần mềm này được dùng khá nhiều ở các quán Internet, công sở hay một khu ký túc xá, khu tập thể.

Bài viết dưới đây sẽ giúp bạn phòng tránh điều đó và thậm chí có thể “trả đũa” lại kẻ đó với “gậy ông đập lưng ông “.

Bạn cũng có thể sử dụng Netcut để phá quá trình download của một kẻ nào lạm dụng mạng chung để kéo file (Download bằng IDM hay xem phim, xem sopcast đều làm ảnh hưởng rất lớn tới tốc độ mạng – nhất là mạng Internet trên Lan có nhiều người dùng ), gây ảnh hưởng đến “cộng đồng ” ( Đang download file lớn, không biết cách resume download từ IDM nữa thì nản ngay, hehe )

Hướng dẫn sử dụng Net Cut và phòng tránh Netcut với Anti – Netcut

Ý nghĩa các mục thông số trong giao diện Net cut
  • Ở phần hostname chính là tên các máy tính trong mạng lan của bạn đang sử dụng internet.
  • ON/OFF : Tình trạng máy tính đó có bị Netcut hay không. Nếu hiện OFF và biểu tượng máy tính màu đỏ tức là đang bị Netcut
  • Protected by Netcut Defender : Máy tính được bảo vệ bởi Netcut Defender
netcut
Giao diện phần mềm Netcut
Cách sử dụng Netcut
Để ngắt mạng Internet của một máy tính cùng mạng Lan với Netcut, bạn chỉ cần làm theo các bước sau :
  • Mở phần mềm Netcut, Chọn 1 máy trong list.
  • Bấm Cut Off để ngắt mạng,
  • Bấm Resume để mở kết nối lại cho máy tính đó

Sau khi ấn Cut off – cứ để  phần mềm đó chờ khoảng 2 – 3 phút mạng của máy đó sẽ bị ngắt. Nếu bạn tắt phần mềm Netcut đi thì máy đó sẽ được kết nối Internet trở lại.

Sử dụng Netcut – Defender
Bạn chỉ cần bật Netcut Defender lên, chọn máy tính cần bảo vệ và bấm Protect, Bạn cũng có thể xem ai đã “chơi xấu” dùng net cut với bạn bằng cách bấm Who cut me.
 
Bị cắt mạng, chưa có phần mềm chống Netcut, phải làm sao ???
Trong trường hợp không có sẵn phần mềm chống Netcut mà bạn bị ngắt mạng thì phải làm sao? Rất đơn giản, bạn hãy làm theo các bước dưới đây :
  • Các bạn click phải lên Mycomputer chọn Properties.
  • Chọn thẻ Computer Name
  • Ở mục Computer Description bạn điền vào 1 tên mới cho máy của mình.
  • Sau đó Ok khởi đông lại máy là vào mạng bình thường.

Lúc này thì hãy nhanh chóng tải một phần mềm chống NetCut đi nhé, không thì lại bị ngắt nữa đấy.

Hướng dẫn cài đặt Net Cut và Anti-Netcut

  • Bước 1 : Download bộ cài bên dưới ở Mục Download
  • Bước 2 : Bạn cần cài đặt WinPcap_4_1_2 trước ( Giúp win7 có thể dùng được Netcut )
  • Bước 3 :  Sau khi cài xong WinPcap, bạn bấm vào file Netcut để cài phần mềm này ( khi nó báo là đòi cài thêm Wincap bạn cứ ấn ok là được – Bởi đã cài đặt ở trước đó )
Cài đặt xong Netcut, bạn cũng nên tạo một lá chắn an toàn cho mình chứ nhỉ. Có rất nhiều phần mềm hỗ trợ chống NetCut ( Anti Netcut, NetCut – Defender, … )
Ở bài viết này, Minh sẽ giới thiệu với các bạn 2 công cụ chống Netcut tốt nhất đó là

  • Anti Netcut 3 – Phần mềm này hoàn toàn đủ để giúp bạn an toàn trước Netcut rồi, tuy nhiên hơi khó dùng với người không thành thạo máy tính vì phải nhập địa chỉ Gateway MAC
  • Netcut – Defender : Dễ sử dụng, phát hành đi kèm với phần mềm Netcut, hỗ trợ tính năng “Who cut me
Cài đặt Anti Netcut và Netcut-Defender
  • Bạn mở thư mục file download giải nén
  • Bấm vào Anti-Netcut hoặc Netcut-defender hoặc để cài đặt bình thường ( Rất đơn giản )
  • Xong!!

Download Netcut mới nhất 2.14, chốngNetcut- Defender 2.15 và Anti Netcut 3

  • Thông tin phần mềm : Netcut 2.14 & Netcut- Defender ; Anti-Netcut
  • Phát hành : Arcai ( Netcut & Netcut-Defender ) ; Tools4Free ( Anti Netcut )
  • Cung cấp : Ngoncolau
  • Hệ điều hành hỗ trợ : Win xp, Win vista, Win 7
  • Dung lượng file ( 3 công cụ ) : 7.89MB
Link download chứa cả 3 phần mềm trong bộ Netcut – Phiên bản mới nhất

Advertisements

Chương 08 – Con Trỏ

 

Khái niệm

Con trỏ là một biến dùng để chứa địa chỉ. Vì có nhiều loại địa chỉ nên cũng có nhiều kiểu con trỏ tương ứng. Kiểu con trỏ int dùng để chứa địa chỉ biến kiểu int. Tương tự ta có con trỏ kiểu float, kiểu double,…
Cũng như với 1 biến bất kỳ nào khác, con trỏ cần được khai báo trước khi sử dụng.
Toán tử lấy địa chỉ (&)
Địa chỉ: Khi khai báo biến, máy sẽ cấp phát cho biến một khoảng nhớ. Địa chỉ của biến là số thứ tự của byte đầu tiên trong một dãy các byte liên tiếp mà máy dành cho biến (các byte được đánh số từ 0).
Máy phân biệt các loại địa chỉ như các biến. Ví dụ như: địa chỉ kiểu int, kiểu float,…
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ớ. Chúng ta không quyết định nơi nào biến đó được đặt, điều đó làm tự động bởi trình biên dịch và hệ điều hành. Nhưng khi hệ điều hành đã gán một địa chỉ cho biến thì chúng ta cần biết biến đó được lưu trữ ở đâu. Điều này được thực hiện bằng cách đặt trước tên biến một dấu và (&).
Ví dụ: x = &y;
Giải thích: Gán cho biến x địa chỉ của biến y vì khi đặt trước tên biến y dấu & ta không nói đến nội dung của biến nữa mà chỉ nói đến địa chỉ của nó trong bộ nhớ.
Giả sử biến y được đặt trọng ô nhớ có địa chỉ là 1202 và có các câu lệnh như sau:
            y = 30;
            z = y;
            x = &y;
            Kết quả: z = 30; x = 1202;
Chú ý: Có thể định nghĩa con trỏ như sau: Những biến lưu trữ địa chỉ của biến khác được gọi là con trỏ. Ở ví dụ trên, biến x là con trỏ.
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 đặt trước tên biến con trỏ một dấu (*).
Ví dụ: Giả sử biến y được đặt trong ô nhớ có địa chỉ là 1202 và có các câu lệnh như sau:
            y = 30;
            z = y;
            x = &y;
            t = *y;
            Kết quả: biến t sẽ mang giá trị là 30.
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 khi khai báo.
Cấu trúc khai báo:
            Kiểu_dữ_liệu       *Tên_con_trỏ;
Chú ý: kiểu dữ liệu ở đây 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    *x; //Khai báo con trỏ x kiểu int
            float   *t; //Khai báo con trỏ t kiểu float
Chú ý: dấu (*) khi khai báo biến kiểu con trỏ chỉ có nghĩa rằng đó là một con trỏ, không liên quan đến toán tử tham chiếu.
Ví dụ đơn giản về sử dụng con trỏ: khai báo, sử dụng toán tử tham chiếu, toán tử lấy địa chỉ:
#include<iostream.h>
main()
{
int     x1 = 5, x2 = 15;
int    *y;
          y = &x1;
          *y = 10;
          y = &x2;
          *y = 20;
         cout<<“Gia tri 1 = “<<x1<<“\n Gia tri 2 = “<<x2;
return 0;
}
Kết quả: x1 = 10; x2 = 20;
Các phép toán
Phép gán
Phép gán chỉ nên thực hiện phép gán cho 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); //ép kiểu
Phép tăng giảm địa chỉ
Ví dụ 1: Các câu lệnh: float   x[30], *px;
                       px  = &x[10];
Cho biết 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 (mỗi giá trị float chứa trong 4 byte), nên các phép tăng giảm địa chỉ được thực hiện trên 4 byte. Nói cách khác:
            px + i trỏ tới phần tử x[10+i];
            px – i trỏ tới phần tử x[10-i];
Ví dụ 2: float  b[40][50];
            b trỏ tới đầu dòng thứ nhất  (phần tử b[0][0];
            b + 1 trỏ tới đầu dòng thứ hai (phần tử b[1][0];
….
Phép truy cập bộ nhớ
Có nguyên tắc là con trỏ float truy nhập tới 4 byte, con trỏ int truy nhập 2 byte, con trỏ char truy nhập 1 byte.
Ví dụ:
            float    *pf;
            int   *pi;
            char  *pc;
Khi đó: Nếu pf trỏ đến byte thứ 10001, thì *pf biểu thị vùng nhớ 4 byte liên tiếp từ byte 10001 đến 10004.
Nếu pi trỏ đến byte thứ 10001, thì *pi biểu thị vùng nhớ 2 byte là 10001 và 10002.
Nếu pc trỏ đến byte thứ 10001, thì *pc biểu thị vùng nhớ 1 byte là byte 10001.
Phép so sánh
Cho phép so sánh các con trỏ cùng kiểu, ví dụ nếu p1 và p2 là 2 con trỏ float thì:
            p1<p2 nếu địa chỉ p1 trỏ tới thấp hơn địa chỉ p2 trỏ tới.
            p1=p2 nếu địa chỉ p1 trỏ tới bằng địa chỉ p2 trỏ tới.
            p1>p2 nếu địa chỉ p1 trỏ tới cao hơn địa chỉ p2 trỏ tới.
Con trỏ hằng
Ví dụ có khai báo sau:
            int   a[20];
            int   *p;
            Lệnh sau sẽ hợp lệ: p = a;
ở đây p và a 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 a 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ì vậy không giống như p – đó là một biến con trỏ bình thường, a, là một con trỏ hằng. Lệnh gán sau đây là không đúng: a = p; bởi vì a 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.
Con trỏ 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.
#include <iostream.h>
int main ()
{
            int  a[5];
            int *p;
            p = a;  *p = 10;
            p++;  *p = 20;
            p = &a[2];  *p = 30;
            p = a + 3;  *p = 40;
            p = a;  *(p+4) = 50;
            for (int n=0; n<5; n++)
            cout << a[n] << “, “;
            return 0;
}
 
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. 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. Vì vậy, các câu lệnh sau là không hợp lệ:
            int number;
            int  *tommy;
            *tommy = &number;
Như đối với mảng, trình biên dịch cho phép chúng ta khởi tạo giá trị mà con trỏ trỏ tới bằng giá trị hằng vào thời điểm khai báo biến con trỏ:
            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:
 
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) = ‘!’;
Hãy nhớ rằng viết terry[4] là hoàn toàn giống với viết *(terry+4) mặc dù biểu thức thông dụng nhất là cái đầu tiên. Với một trong hai lệnh trên xâu do terry trỏ đến sẽ có giá trị như sau:
 
Con trỏ trỏ tới con trỏ
C++ cho phép sử dụng các con trỏ trỏ tới các con trỏ khác giống như là trỏ tới dữ liệu. Để làm việc đó chúng ta chỉ cần thêm một dấu sao (*) cho mỗi mức tham chiếu.
            char  a;
            char *b;
            char **c;
            a = ‘z’;
            b = &a;
            c = &b;
giả sử rằng a,b,c được lưu ở các ô nhớ 7230, 8092 and 10502, ta có thể mô tả đoạn mã trên như sau:
                         a                     b                      c
                        “z”      ß        7230    ß        8092
                        7230                8092                10502
Điểm mới trong ví dụ này là biến c, chúng ta có thể nói về nó theo 3 cách khác nhau, mỗi cách sẽ tương ứng với một giá trị khác nhau:
            c là một biến có kiểu char ** mang giá trị 8092;
            *c là một biến có kiểu char * mang giá trị là 7230;
            **c là một biến có kiểu char mang giá trị ‘z’;
Con trỏ không kiểu
Con trỏ không kiểu là một loại con trỏ đặc biệt. Nó có thể trỏ tới bất kì loại dữ liệu nào, từ giá trị nguyên hoặc thực cho tới một xâu kí tự. Hạn chế duy nhất của nó là dữ liệu được trỏ tới không thể được tham chiếu tới một cách trực tiếp (chúng ta không thể dùng toán tử tham chiếu * với chúng) vì độ dài của nó là không xác định và vì vậy chúng ta phải dùng đến toán tử chuyển kiểu dữ liệu hay phép gán để chuyển con trỏ không kiểu thành một con trỏ trỏ tới một loại dữ liệu cụ thể.
Một trong những tiện ích của nó là cho phép truyền tham số cho hàm mà không cần chỉ rõ kiểu.
Ví dụ:
#include <iostream.h>
void increase (void* data, int type)
{
       switch (type)
  {
       case sizeof(char) : (*((char*)data))++; break;
       case sizeof(short): (*((short*)data))++; break;
       case sizeof(long) : (*((long*)data))++; break;
  }
}
int main ()
{
  char a = 5;
  short b = 9;
  long c = 12;
  increase (&a,sizeof(a));
  increase (&b,sizeof(b));
  increase (&c,sizeof(c));
  cout << (int) a << “, ” << b << “, ” << c;
  return 0;
}
Kết quả6, 10, 13
sizeof là một toán tử của ngôn ngữ C++, nó trả về một giá trị hằng là kích thước tính bằng byte của tham số truyền cho nó, ví dụ sizeof(char) bằng 1 vì kích thước của char là 1 byte.
Con trỏ hàm
C++ cho phép thao tác với các con trỏ hàm. Tiện ích này cho phép truyền một hàm như là một tham số đến một hàm khác. Để có thể khai báo một con trỏ trỏ tới một hàm chúng ta phải khai báo nó như là khai báo mẫu của một hàm nhưng phải bao trong một cặp ngoặc đơn () tên của hàm và chèn dấu sao (*) đằng trước.
Ví dụ:
#include <iostream.h>
int addition (int a, int b)
return (a+b); }
int subtraction (int a, int b)
return (a-b); }
int (*minus)(int,int) = subtraction;
int operation (int x, int y, int (*functocall)(int,int))
{
  int g;
  g = (*functocall)(x,y);
  return (g);
}
int main ()
{
  int m,n;
  m = operation (7, 5, &addition);
  n = operation (20, m, minus);
  cout <<n;
  return 0;
}
Trong ví dụ này, minus là một con trỏ toàn cục trỏ tới một hàm có hai tham số kiểu int, con trỏ này được gám để trỏ tới hàm subtraction, tất cả đều trên một dòng:
int (* minus)(int,int) = subtraction;
By dungkcna113 Posted in C/C++

Chương 07 – MẢNG

 

Khái niệm

Mảng thực chất là một biến được cấp phát bộ nhớ liên tục và bao gồm nhiều biến thành phần.
Các thành phần của mảng là tập hợp các biến có cùng kiểu dữ liệu và cùng tên. Do đó để truy xuất các biến thành phần, ta dùng cơ chế chỉ mục (chỉ số).
Khai báo mảng
Cú pháp:
Kiểu_mảng> < Tên_mảng > [ < Số_phần_tử_tối_đa> ] ;
Trong đó:
Kiểu_mảng: đây là kiểu của mảng, là tên một kiểu dữ liệu đã tồn tại, có thể là kiểu chuẩn hoặc kiểu dữ liệu do người lập trình định nghĩa .
Tên_mảng: là tên của mảng, do người lập trình đặt, theo quy tắc về tên của C/C++.
Số_phần_tử: là hằng (hoặc biểu thức hằng) nguyên, dương là số phần tử của mảng.
Ví dụ:
int   a[10]; // Khai báo mảng a, có số phần tử tối đa là 10, kiểu dữ liệu của mảng a là int.
float   MT[20]; //Khai báo mảng MT, có số phần tử tối đa là 20, kiểu dữ liệu của mảng MT làfloat.
Truy xuất đến các phần tử của mảng
Cú pháp :tên_mảng [chỉ_số]
Ví dụ: a[1], MT[3];
chỉ_số là số thứ tự của phần tử trong mảng, các phần tử của mảng được đánh chỉ số bắt đầu từ 0. Với mảng có n phần tử thì các phần tử của nó có chỉ số là 0, 1,..,n-1.
Khởi tạo mảng
Kiểu_mảng     tên_mảng [ số_phần_tử ] = {gt_0, gt_1,..,gt_k};
           hoặc
Kiểu_mảng    tên_mảng [ ] = {gt_0, gt_1,..,gt_k};
Trong đó các thành phần Kiểu_mảng , tên_mảng, số_phần_tử như trong phần khai báo mảng. gt_0, gt_1,.., gt_k là các giá trị khởi đầu (gọi là bộ khởi đầu) cho các phần tử tương ứng của mảng, tức là gán tuần tự các giá trị trong bộ khởi đầu cho các phần tử của mảng từ trái qua phải.
Trong dạng thứ nhất, số giá trị trong bộ khởi đầu chỉ có thể <= số phần tử của mảng (k ≤ số_phần_tử). Khi đó những phần tử mảng thừa ra (không có giá trị khởi đầu) sẽ tự động được gán bằng 0 (trong trường hợp mảng số, nếu là con trỏ sẽ là NULL (rỗng) ).
Ví dụ:
int a[3] ={ 1, 3, 4}; thì giá trị của a[0] là 1, a[1] là 3, a[2] là 4.
int b[5] ={1,2}; thì giá trị của b[0] là 1, b[1] là 2, b[3]=b[4] là 0.
với mảng các ký tự hoặc xâu ký tự thì có hai cách khởi đầu như sau:
char c[4] ={‘a’,’b’,’c’ }; // c[0] là ‘a’, c[1] là ‘b’, c[2] là ‘c’, c[3] là ‘’
char s[10] =”ABC”; // tương đương với char s[10] ={‘A’,’B’,’C’,’’}
(nếu số giá trị trong bộ khởi đầu > số phần tử mảng chương trình dịch sẽ báo lỗi)
Trong dạng thứ hai, chúng ta không xác định số phần tử của mảng, trong trường hợp này chương trình biên dịch sẽ tự động xác định kích thước (số phần tử) của mảng theo số giá trị trong bộ khởi đầu.
Ví dụ:
int a[] ={1,3,4};
thì a là mảng có 3 phần tử, giá trị của a[0] là 1, a[1] là 3, a[2] là 4.
Ví dụ 1: Viết chương trình nhập vào một mảng A có n phần tử kiểu nguyên, n<=20, n được nhập từ bàn phím. In các phần tử của mảng theo trật tự xuôi, ngược (theo trật tự chỉ số).
#include<iostream.h>
main()
{
const max = 20;
int n, i, a[max];
                        do   {
                        cout<<“Nhap vao so phan tu cua mang: “;                             cin>>n;
                                }
                       
while (n < 1 || n > max);
cout<<“Nhap vao mang a: “<<endl;
for (i = 0; i<n; i++)
cin>>a[i];
                        cout<<“Cac phan tu mang theo TT xuoi la: “;
                        for (i = 0; i<n; i++)
                        cout<<a[i]<<“\t”;
                        cout<<endl;
                        cout<<“Cac phan tu mang theo TT nguoc la: “;
                        for (i = n-1;i>=0; i–)
                        cout<<a[i]<<“\t”;
return 0;
}
Ví dụ 2: Nhập vào 2 mảng A và B, có số phần tử tối đa là 10. Tính tổng của A và B.
//Tinh tong cua  C = A + B
#include<iostream.h>
main()
{
const max = 10;
int n, i, a[max], b[max], c[max];
do {
  cout<<“Nhap vao so phan tu cua mang: “; cin>>n;
            }
  while (n < 1 || n > max);
  cout<<“Nhap vao so PT mang a: “<<endl;
  for (i = 0; i<n; i++)
  cin>>a[i];
cout<<“Nhap vao so PT mang b: “<<endl;
  for (i = 0; i<n; i++)
  cin>>b[i];
  cout<<“Tong C = A + B = “;
  for (i = 0; i< n; i++)
  c[i] = a[i] + b[i];
  for (i = 0; i<n; i++)
  cout<<c[i]<<“\t”;
  return 0;
  }
Dùng mảng làm tham số
Vào một lúc nào đó có thể chúng ta cần phải truyền một mảng tới một hàm như là một tham số. Trong C++, việc truyền theo tham số giá trị một khối nhớ là không hợp lệ, ngay cả khi nó được tổ chức thành một mảng. Tuy nhiên chúng ta lại được phép truyền địa chỉ của nó, việc này cũng tạo ra kết quả thực tế giống thao tác ở trên nhưng lại nhanh hơn nhiều và hiệu quả hơn.
Để có thể nhận mảng là tham số thì điều duy nhất chúng ta phải làm khi khai báo hàm là chỉ định trong phần tham số kiểu dữ liệu cơ bản của mảng, tên mảng và cặp ngoặc vuông trống.
Ví dụ, hàm sau:
            void procedure (int arg[])
nhận vào một tham số có kiểu “mảng của char” và có tên arg. Để truyền tham số cho hàm này một mảng được khai báo:
            int myarray [40];
chỉ cần gọi hàm như sau:
            procedure (myarray);
Ví dụ 1:
#include <iostream.h>
 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;
}
Ví dụ 2: Tính tổng C = A + B
#include <iostream.h>
void nhapmang(int a[], int n);
void inmang(int a[], int n);
void tong(int A[],int B[],int C[],int n);
void main()
{
     const int max = 20;
     int A[max], B[max],C[max];
     int n;
     do {
            cout<<“\nNhap so phan tu mang = “;
            cin>>n;
           }
            while(n<1 || n>max);
     cout<<“\nNhap A \n”;
     nhapmang(A,n);
     cout<<“\nNhap B \n”;
     nhapmang(B,n);
     tong(A,B,C,n);
     cout<<“\nmang A: “;
     inmang(A,n);
     cout<<“\nmang B: “;
     inmang(B,n);
     cout<<“\nmang C: “;
     inmang(C,n);
}
void nhapmang(int a[], int n){
            int i;
            cout<<“\nNhap mang co so phan tu: “<<n;
            for(i=0; i<n; i++)
            {
                        cout<<“\nPhan tu thu”<<“[“<<i<<“]”;
                        cin>>a[i];
            }
}
void inmang(int a[], int n){
            int i;
            for(i=0; i<n; i++)
            cout<<a[i];
}
void tong(int A[],int B[],int C[],int n){
            int i;
            for (i = 0; i<n; i++)
            C[i]=A[i]+B[i];
}
 
Mảng hai chiều
Định nghĩa
Mảng hai chiều có thể hiểu như bảng gồm các dòng các cột, các phần tử thuộc cùng một kiểu dữ liệu nào đó. Mảng hai chiều được định nghĩa như sau.
Cú pháp:
            Kiểu_mảng tên_mảng [sd][sc];
Trong đó:
– Kiểu_mảng: đây là kiểu của mảng, là tên một kiểu dữ liệu đã tồn tại, có thể là kiểu chuẩn hoặc kiểu dữ liệu do người lập trình định nghĩa.
– Tên_mảng: là tên của mảng, do người lập trình đặt, theo quy tắc về tên của C/C++.
– sd, sc: là hằng (hoặc biểu thức hằng) nguyên, dương tương ứng là số dòng và số cột mảng, số phần tử của mảng sẽ là sd*sc.
Ví dụ:
int a[2][5]; // a là mảng số nguyên có 2 dòng, 5 cột (có 10 phần tử).
float D[3][10]; // D là mảng số thực có 3 dòng, 10 cột (có 30 phần tử).
char DS[5][30]; // DS là mảng kí tự có 5 dòng, 30 cột.
Truy xuất các phần tử của mảng hai chiều
Một phần tử của mảng 2 chiều được xác định qua tên (tên của mảng) và chỉ số dòng, chỉ số cột của nó trong mảng theo cú pháp sau:
            tên_mảng [csd][csc]
Với csd là số nguyên xác định chỉ số dòng và csc là số hiệu cột cũng như trong mảng 1 chiều các chỉ số được tính từ 0. Tức là 0 ≤csd ≤sd-1 và 0≤csc≤sc-1.
Khởi tạo giá trị mảng hai chiều
Các phần tử mảng hai chiều cũng có thể được khởi đầu giá trị theo cú pháp (4 dạng sau):
+ Kiểu_mảng tên_mảng [sd][sc]={{kđ_dòng_1},{ kđ_dòng_2},..,{ kđ_dòng_k}};
+ Kiểu_mảng tên_mảng [ ][sc] = {{kđ_dòng_1},{ kđ_dòng_2},..,{ kđ_dòng_k}};
+ Kiểu_mảng tên_mảng [sd][sc] = { gt_1, gt_2,…,gt_n };
+ Kiểu_mảng tên_mảng [ ][sc] = { gt_1, gt_2,…,gt_n };
Dạng 1: có k bộ giá trị sẽ được gán cho k dòng đầu tiên của mảng (k ≤ sd ), với mỗi dòng (được coi như mảng một chiều) được khởi tạo giá trị như mảng một chiều:
dòng thứ nhất được khởi đầu bởi {kđ_dòng_1}, dòng thứ hai được khởi đầu bởi {kđ_dòng_1},.., dòng thứ k được khởi đầu bởi {kđ_dòng_k}. Yêu cầu k ≤ sd, ngược lại chương trình sẽ báo lỗi.
Các dòng cuối của mảng nếu không có bộ khởi đầu tương ứng thì sẽ được tự động gán giá trị 0 (hoặc NULL nếu là con trỏ).
Dạng 2: (không xác định số dòng) chương trình dịch sẽ tự động ấn định số dòng của mảng bằng số bộ khởi đầu ( = k), sau đó thực hiện khởi đầu như dạng 1.
Dạng 3: n giá trị trong bộ khởi đầu được gán cho các phần tử mảng theo cách: sc giá trị đầu tiên trong các giá trị khởi đầu (gt_1,..,gt_sc) được gán tuần tự cho các phần tử của dòng thứ nhất trong mảng, sc phần tử kế tiếp sẽ gán cho các phần tử ở dòng thứ 2,… nếu phần tử nào của mảng không có giá trị khởi đầu sẽ được gán 0 (con trỏ là NULL) – với điều kiện n ≤ sd*sc, ngược lại là lỗi.
Dạng 4: số dòng của mảng sẽ được chương trình tự tính theo số giá trị trong bộ khởi đầu theo công thức sd = (n/sc) +1, và khởi đầu như dạng 3.
Ví dụ 1: int a[3][2] = {{1,2},{3},{4,5}}; thì các phần tử của a như sau:
a[0][0]=1, a[0][1]=2, a[1][0]=3, a[1][1]= 0, a[2][0]=4,a[2][1]=5;
Ví dụ 2: int b[ ][2] = {{1,2},{3},{4,5}};
thì là mảng 3 dòng, 2 cột các phần tử của b như sau:
b[0][0]=1, b[0][1]=2, b[1][0]=3,b[1][1]= 0, b[2][0]=4,b[2][1]=5;
Ví dụ 3: int c[ ][2] = {1,2,3,4,5};
thì số dòng của c là mảng 5/2 +1 =3 dòng, các phần tử của a như sau:
c[0][0]=1, c[0][1]=2, c[1][0]=3,c[1][1]= 4, b[2][0]=5,b[2][1]=0;
Viết chương trình nhập vào mảng A(n, m) với 1<=n,m<=5 các số nguyên.
Yêu cầu:
+ In mảng A ra màn hình.
+ In ra màn hình các phần tử chẵn của mảng.
+ In ra màn hình các phần tử lẻ của mảng.
#include<iostream.h>
main()
{
     const max = 5;//Kich thuoc toi da
     int   a[max][max];
     int   n,m,i,j;
     do   {
             cout<<“Nhap so dong cua mang = “;cin>>n;
             cout<<“Nhap so cot cua mang = “; cin>>m;
             }
     while (n<1 || n>max || m<1 || m>max);
     cout<<“Nhap cac gia tri cua mang: “<<endl;
     for (i = 0; i<n; i++)
     for (j = 0; j<m; j++)
            {
              cin>>a[i][j];
            }
     cout<<“Cac PT cua mang la: “<<”  “;
     for (i = 0; i<n; i++)
              {
              cout<<endl;
                 for (j = 0; j<m; j++)
              cout<<a[i][j]<<”  “;
              }
     cout<<“\n Cac PT chan cua mang la: “;
for (i = 0; i<n; i++)
for (j = 0; j<m; j++)
     {
          if (a[i][j] % 2 == 0)
          cout<<a[i][j]<<“\t”;
     }
cout<<“\n Cac PT le cua mang la: “;
     for (i = 0; i<n; i++)
     for (j = 0; j<m; j++)
     {
          if (a[i][j] % 2 != 0)
          cout<<a[i][j]<<“\t”;
     }
}
By dungkcna113 Posted in C/C++

Chương 06 – HÀM

 

Khái niệm

Hàm là một đoạn chương trình độc lập thực hiện trọn vẹn một công việc nhất định sau đó trả về giá trị cho chương trình gọi nó, hay nói cách khác hàm là sự chia nhỏ của chương trình.
Cú pháp khai báo nguyên mẫu hàm
            <Kiểu_hàm> Tên_hàm  ([Danh_sách_tham_số]);
Trong đó:
Tên_hàm: là một tên hợp lệ theo quy tắc về tên của ngôn ngữ C/C++. Mỗi hàm có tên duy nhất và không được trùng với các từ khóa. Tên hàm sẽ được dùng để gọi hàm.
Kiểu_hàm: Hàm có thể trả về một giá trị cho nơi gọi, giá trị đó thuộc một kiểu dữ liệu nào đó, kiểu đó được gọi là kiểu hàm. Kiểu hàm có thể là kiểu chuẩn cũng có thể là kiểu do người dùng định nghĩa. Nếu hàm không trả về giá trị thì kiểu hàm là void.
Danh_sách_tham_số: Hàm có thể nhận dữ liệu vào thông qua các tham số của nó (tham số hình thức), các tham số này cũng thuộc kiểu dữ liệu xác định. Có thể có nhiều tham số, các tham số cách nhau bởi dấu phẩy (,). Trong nguyên mẫu không bắt buộc phải có tên tham số nhưng kiểu của nó thì bắt buộc. Nếu hàm không có tham số chúng ta có thể để trống phần này hoặc có thể khai báo là void.
Ví dụ:
int max(int a, int b); // khai báo nguyên mẫu hàm max, có hai tham số kiểu int, kết quả trả về kiểu int.
float f(float, int); // nguyên mẫu hàm f, có hai tham số, tham số thứ nhất kiểu float, tham số thứ 2 kiểu int, kết quả trả về kiểu float.
void nhapmang(int a[], int ); // hàm nhapmang, kiểu void (không có giá trị trả về), tham số thứ nhất là một mảng nguyên, tham số thứ 2 là một số nguyên.
void g(); // hàm g không đối, không kiểu.
Định nghĩa hàm
Cú pháp:
            <kiểu_hàm> <tên_hàm>([khai_báo_tham_số])
                {
                    < thân hàm>
               }
Ví dụ:
unsigned long   giaithua (int n)
{
        unsigned long ketqua =1;
        int i;
        for (i =2; i<=n; i++)
        ketqua = ketqua*i;
        return ketqua;
}
Kết quả trả về của hàm – lệnh return
Nếu hàm có giá trị trả về (kiểu hàm khác void) thì trong thân hàm trước khi kết thúc phải có câu lệnh trả về giá trị:
                                    return <giá trị>;
<giá_trị> sau lệnh return chính là giá trị trả về của hàm, nó phải có kiểu phù hợp với kiểu của hàm được khai báo trong dòng tiêu đề. Trường hợp hàm void chúng ta có thể dùng câu lệnh return (không có giá trị) để kết thúc hàm hoặc khi thực hiện xong lệnh cuối cùng (gặp } cuối cùng) hàm cũng kết thúc.
Lời gọi hàm và cách truyền tham số cho hàm
•         Một hàm có thể gọi thực hiện thông qua tên hàm, với những hàm có tham số thì trong lời gọi phải truyền cho hàm các tham số thực sự (đối số) tương ứng với các tham số hình thức.
•         Khi hàm được gọi và truyền tham số phù hợp thì các lệnh trong thân hàm được thực hiên bắt đầu từ lệnh đầu tiên sau dấu mở móc { và kết thúc khi gặp lệnh return, exit hay gặp dấu đóng móc } kêt thúc hàm.
Cú pháp:
              <tên_hàm> ([danh sách các tham số thực sự]);
Các tham số thực sự phải phù hợp với các tham số hình thức
Số tham số thực sự phải bằng số tham số hình thức.
Tham số thực sự được truyền cho các tham số hình thức tuần tự từ trái sang phải, tham số thực sự thứ nhất truyền cho tham số hình thức thứ nhất, tham số thực sự thứ 2 truyền cho tham số hình thức thứ 2,.. kiểu của các tham số thực sự phải phù hợp với kiểu của các tham số hình thức. Sự phù hợp ở đây được hiểu là kiểu trùng nhau hoặc kiểu của tham số thực sự có thể ép về kiểu của tham số hình thức.
Đệ quy
Một hàm được gọi có tính đệ qui nếu trong thân của hàm đó có lệnh gọi lại chính nó một cách tường minh hay tiềm ẩn.
Ví dụ 1: Tính tổng S = 1 + 2 + 3 + … + n  (n là số nguyên dương, được nhập từ bàn phím).
Thuật toán giải bằng phương pháp đệ quy như sau:
long   TongS (int n)
{
if(n==0)
return 0;
return ( TongS(n-1) + n );
}
By dungkcna113 Posted in C/C++

Chương 05.3 – Câu Lênh Break , Continue ,Goto và Hàm Exit()

 

Câu lệnh break, continue, goto và hàm exit

            Câu lệnh break
-Câu lệnh break cho phép ra khỏi các chu trình với các toán tử for, while và switch.
-Khi có nhiều chu trình lồng nhau, câu lệnh break sẽ kết thúc câu lệnh điều    khiển đang sử dụng và ra khỏi bên trong nhất chứa nó không cần điều kiện gì.
-Mọi câu lệnh break có thể thay bằng câu lệnh goto với nhãn thích hợp.
Ví dụ: Cho phép người dùng nhập liên tục giá trị n cho đến khi nhập âm thì dừng.
#include<iostream.h>
void main()
{
int n;
while (1)
       {
             cout<<“\nNhap n: ”; cin>>n;
             if(n<0)
             break;
        }
}
 
            Câu lệnh Continue
-Continue dùng để bắt đầu một vòng mới của chu trình chứa nó
Trong while và do .. while, lệnh continue chuyển điều khiển về thực hiện ngay phần kiểm tra, còn trong vòng lặp for điều khiển được chuyển về bước khởi đầu lại (tức là bước: tính biểu thức 3, sau đó quay lại bước 2 để bắt đầu một vòng mới của chu trình).
Chú ý: Lệnh continue chỉ áp dụng cho chu trình, không áp dụng cho switch.
Ví dụ: In ra màn hình giá trị từ 10 đến 20 trừ đi số 13 và số 17.
#include<iostream.h>
void main()
{
        for (int i=10 ; i<=20; i++)
        {
             if (i==13||i==17)
             continue;
             cout<<i<<“,”;
         }
        cout<<“Ket thuc;”;
}
            Câu lệnh Goto
-Lệnh goto cho phép nhảy vô điều kiện tới bất kỳ điểm nào trong chương trình.
Ví dụ:
#include <iostream.h>
int main ()
{
        int n=10;
        loop: ;
        cout << n << “, “;
        n–;
        if (n>0) goto loop;
        cout << “Kết thúc!”;
        return 0;
}
            Hàm Exit
Hàm exit() trong C/C++ được sử dụng để thoát khỏi chương trình. Hàm này, khi được triệu gọi sẽ ngay lập tức kết thúc chương trình và chuyển quyền điều khiển cho hệ điều hành.
              Cú pháp:   
                                 exit (int  mã_trả_về);
mã_trả_về thường là số 0. Số 0 sẽ xác định việc kết thúc chương trình một cách bình thường. Tuy nhiên có một vài trường hợp mã_trả_về là những số khác 0 để xác định một vài loại lỗi.
By dungkcna113 Posted in C/C++

Chương 05.2 – Cấu trúc vòng lặp Do While,For

 

Cấu trúc lặp do…while

Cấu trúc lặp “do”
Cú pháp:
                        do
                        Khối lệnh;
                        while (biểu thức);
Giải thích cú pháp:
Bước 1: thực hiện khối lệnh sau do.
Bước 2: kiểm tra giá trị biểu thức <biểu thức> sau while, nếu có giá trị ‘đúng’ ( khác 0) thì lặp lại bước 1, nếu ‘sai’ (=0) thì kết thúc vòng lặp.
 Biểu diễn bằng lưu đồ: 
 
Ví dụ 1: Nhập vào 1 số.nếu không nhập số 0 thì vòng lặp sẽ tiếp tục đòi nhập
#include<iostream.h>
main()
{
unsigned long n;
do    
        {
            cout<< “Nhap vao 1 day so khong cach”; cin>>n;
            cout<< “Ban da nhap so”<<n<<endl;
         }
while (n!=0);
return 0;
}
 
            Cấu trúc lặp “while”
Cú pháp:
            while(biểu thức)
            Khối lệnh;
Sự hoạt động của vòng lặp while:
Bước 1: tính giá trị của (biểu thức) sau while
Bước 2: nếu giá trị tính được của (biểu thức) là ‘sai’ (==0) thì kết thúc  vòng lặp while.
Bước 3: nếu giá trị của (biểu thức) là ‘đúng’ (!=0) thì thực hiện khối lệnh sau while.
Bước 4: quay lại bước 1
Chú ý: Thân while có thể được thực hiện một lần hoặc nhiều lần và cũng có thể không được thực hiện lần nào nếu ngay từ đầu biểu thức sau while đã sai.
Biểu diễn bằng lưu đồ: 
 
Ví dụ 1:Viết 1 chương trình đếm ngược
#include<iostream.h>
main()
{
    int n;
    cout<< “Nhap vao  1 so (hay day so khong cach)”; cin>>n;
    while (n>0)
                 {
                 cout<< n<< “,”;
                  –n;
                  }
    cout<< “Ket thuc”;
    return  0;
}
 
Ví dụ 2: Viết chương trình tính và in S = 1 +1/(2!) +1/(3!)+..+1/(n!) với n nhập từ bàn phím, 0<n<10.
#include <iostream.h>
const int Max =10; // gioi han
void main()
{
    int n, k ;
    float S, pt;
    cout<<“\nNhap n = “;
    cin>>n;
    while((n<=0)||(n>Max))
            {
                cout<<“\nNhap lai n (0<n<=”<<Max;
                cin>>n;
            }
    S=pt=1; k=2;
    while(k<=n)
            {
                pt /=k;
                S+=pt;
                k++;
            }
    cout<<“\nGia tri tong S = “<<S;
}
 
Cấu trúc lặp for
Cú pháp:
            for (biểu thức 1; biểu thức 2; biểu thức 3)
            Khối lệnh;
Trong đó:
    Biểu thức 1: biểu thức khởi đầu.
    Biểu thức 2: biểu thức điều kiện – điều kiện lặp.
    Biểu thức 3: bước nhảy – thường dùng với ý nghĩa là thay đổi bước nhảy.
Cả 3 biểu thức này đều là tuỳ chọn, chúng có thể vắng mặt trong câu lệnh cụ thể nhưng các dấu chấm phẩy vẫn phải có.
Sự hoạt động của vòng lặp for:
•          Bước 1: Thực hiện biểu thức khởi đầu – Biểu thức 1.
•          Bước 2: Tính giá trị biểu thức 2 để xác định điều kiện lặp.
  Nếu biểu thức 2 có giá trị ‘sai’ (==0) thì ra khỏi vòng lặp.
  Ngược lại, nếu biểu thức có giá trị ‘đúng’ ( khác 0) thì chuyển tới bước 3.
•          Bước 3: Thực hiện khối lệnh sau for ( thân của for ), chuyển tới bước 4.
•          Bước 4: Thực hiện biểu thức 3, rồi quay về bước 2.
Biểu diễn bằng lưu đồ: 
Ví dụ 1: Đếm ngược từ 10->1
#include<iostream.h>
main()
{
          for (int n = 10; n>0; n–)
          {
              cout<< n<< “,”;
          }
cout<< “Ket thuc”;
return 0;
}
Ví dụ 2: Nhập vào một dãy số nguyên, tìm số lớn nhất và nhỏ nhất trong dãy.
#include <iostream.h>
void main()
{
                        int n,a,max,min,i;
                        do
                        {
                                     cout<<“Nhap so phan tu cua day : “;
                                     cin>>n;
                        }
                        while(n<1);
cout<<“Nhap so :”; cin>>a;
max=min=a;
for(i=2; i<=n; i++)
             {
                          cout<<“Nhap so : “; cin>>a;
                          if(a>max)
                          max=a;
                          else if(a<min)
                          min =a;
             }
cout<<“\nGia tri lon nhat =”<<max<<“\nGia tri nho nhat = “<<min;
}
By dungkcna113 Posted in C/C++

Chương 5.1 – Các cấu trúc điều khiển (IF- else,Switch,While…)

 

Lệnh đơn và lệnh phức

Lệnh đơn
Một biểu thức kiểu như: a =5; a+ =6;… trở thành câu lệnh khi có đi kèm theo dấu chấm phẩy (;) phía cuối câu.
            Ví dụ:
a = 5;
a+=6;
Lệnh phức hay khối lệnh
Lệnh phức là một dãy các các câu lệnh được bao bởi cặp dấu ngoặc nhọn {}.
Ví dụ 1:
            {
                S+=(i*i);
                i++;
            }
Ví dụ 2:
            {
                cout<<a[i][j]<<”  “;
                if (j==i)
                        cout<<“\n”;
            }
Cấu trúc điều kiện if … else
Dạng khuyết
If  (biểu thức điều kiện)
    {
        Khối lệnh;
    }
Cách hoạt động: Đầu tiên, chương trình kiểm tra biểu thức điều kiện sau if. Nếu biểu thức điều kiện đúng thì các câu lệnh trong khối lệnh trong cấu trúc if được thực hiện. Ngược lại, chương trình sẽ thoát ra khỏi cấu trúc if và thực hiện các lệnh tiếp theo sau cấu trúc if.
Biểu diễn dưới dạng lưu đồ cách hoạt động của cấu trúc if:
 
Dạng đầy đủ
if (biểu thức điều kiện)
    {
        Khối lệnh 1;
    }
else
    {
        Khối lệnh 2;
    }
Cách hoạt động: Đầu tiên, chương trình kiểm tra biểu thức điều kiện sau if, nếu biểu thức điều kiện đúng thì thực hiện các câu lệnh trong khối lệnh 1. Ngược lại, nếu biểu thức điều kiện sai sẽ thực hiện các câu lệnh trong khối lệnh 2.
Biểu diễn dưới dạng lưu đồ:
Ví dụ : Giải phương trình bậc 1: ax + b = 0
#include<iostream.h>
#include<math.h>
int main()
        {

 

int  a,b;
float x;
cout<<“Nhap a va b:”<<“\n”;
cin>>a>>b;
if (a==0 && b==0)
    cout<<“Bat phuong trinh co vo so nghiem”;
if (a==0 && b!=0)
    cout<<“Bat phuong trinh vo nghiem”;
if (a!=0)
    cout<<“Bat phuong trinh co nghiem x = “<<-b/a;
        }
Cấu trúc lựa chọn switch … case
Cấu trúc switch..case cho phép lựa chọn một nhánh trong nhiều khả năng tùy vào điều kiện xảy ra.
                       
             Cú pháp:

switch (Biểu thức nguyên)

            {
                case n1: Khối lệnh 1;
                case n2: Khối lệnh 2;
                …
                case nk: Khối lệnh k;
                [default: Khối lệnh; ]
            }
Trong đó:
ni là các số nguyên, hằng ký tự hoặc biểu thức hằng. Các ni cần có giá trị khác nhau.
Đoạn chương trình nằm trong cặp ngoặc nhọn {} là thân của switch.
default, case là các từ khóa. default là thành phần không bắt buộc.
Cách hoạt động:
Đầu tiên <biểu thức nguyên> được tính, sau đó lần lượt so sánh giá trị của <bt nguyên> với các biểu thức hằng <n1>, <n2>,..<nk>.
Nếu giá trị của một biểu thức hằng thứ k trong các biểu thức này trùng với giá trị của <biểu thức nguyên> thì chương trình sẽ thực hiện các lệnh bắt đầu từ khối lệnh k và tiếp tục các lệnh phía dưới cho tới khi:
+ Gặp câu lệnh : break (tất nhiên nếu gặp các câu lệnh return, exit thì cũng kết thúc).
+ Gặp dấu đóng móc } hết cấu trúc switch.
Nếu <biểu thức nguyên> không trùng với giá trị nào trong các biểu thức hằng thì khối lệnh (các lệnh sau mệnh đề default nếu có) sẽ được thực hiện, rồi ra khỏi cấu trúc switch.
Ví dụ 1: Sử dụng cấu trúc switch..case, hãy viết chương trình: nếu nhập vào là ‘P’ hoăc ‘p’ thì hiển thị dòng chữ “Chao cac ban”
#include<iostream.h>
main()
        {
            char ch;
            cout<<“Nhap vao ky tu X hoac x: “; cin>>ch;
            switch (ch)
                {
                    case ‘x’:
                    case ‘X’:  
                    cout<<“Chao cac ban”;
                }
        }
Ví dụ 2: Viết chương trình sử dụng cấu trúc switch..case, nhập 2 số nguyên x, y từ bàn phím, chương trình đưa ra lựa chọn:
+ Nếu người sử dụng nhập ‘+’: Thực hiện: x + y;
+ Nếu người sử dụng nhập ‘-‘: Thực hiện: x – y;
+ Nếu người sử dụng nhập ‘*’: Thực hiện: x * y;
+ Nếu người sử dụng nhập ‘/‘: Thực hiện: x / y;
Nếu người sử dụng không nhập một trong các toán tử trên thì đưa ra dòng thông báo: “Khong hieu toan tu nay!”.
#include <iostream.h>
 int main()
 {
    int X;
    cout<< “Nhap vao so thu nhat:”;
    cin>>X;
    int Y;
    cout<< “Nhap vao so thu hai:”;
    cin>>Y;
    char Op;
    cout<<“Nhap vao toan tu (+-*/):”;
    cin>>Op;
    switch(Op)
    {
case ‘+’:
            cout<<“Ket qua:”<<X+Y<<“\n”;
            break;
case ‘-‘:
            cout<<“Ket qua:”<<X-Y<<“\n”;
            break;
case ‘*’:
            cout<<“Ket qua:”<<long(X)*Y<<“\n”;
            break;
case ‘/’:
            if (Y)
            cout<<“Ket qua:”<<float(X)/Y<<“\n”;
            else
            cout<<“Khong the chia duoc!” <<“\n”;
            break;
            default :
            cout<<“Khong hieu toan tu nay!”<<“\n”;
             }
             return 0;
 }

 

By dungkcna113 Posted in C/C++

CHƯƠNG 04 – Các thành phần và các kiểu dữ liệu cơ bản

 

Các thành phần

Các thành phần trong C++ bao gồm:
+ Từ khóa.
+ Các khai báo biến, hằng.
+ Các cấu trúc điều khiển.
+ Biểu thức và các phép toán.
+ Các định nghĩa, khai báo hàm, khai báo kiểu,…
Các kiểu dữ liệu cơ bản
3 thông tin đặc trưng của kiểu dữ liệu:
– Tên kiểu dữ liệu.
– Kích thước vùng nhớ biểu diễn nó,miền giá trị.
– Các phép toán có thể sử dụng.
Các kiểu dữ liệu đơn giản trong C++ chỉ là các kiểu số, thuộc hai nhóm chính đó là số nguyên và số thực (số dấu phẩy động).
Kiểu số nguyên
 
Kiểu số thực: biểu diễn theo ký pháp khoa học gồm phần định trị và phần mũ viết sau chữ E để biểu diễn số mũ cơ số 10.
Ví dụ: 3.14 = 314*10-2 sẽ được viết theo ký pháp khoa học là: 314E – 2.
Hoặc: 314 = 3.14 *102 sẽ được viết theo ký pháp khoa học là: 3.14E + 2.
 
Hằng
Khái niệm
Hằng là đại lượng có giá trị thuộc một kiểu dữ liệu nhất định, giá trị của hằng không thể thay đổi trong thời gian tồn tại của nó.
Có hai loại hằng:
Hằng không tên (hằng thường): là các giá trị cụ thể tức thời như: 8, 9.5 hoặc ‘d’
Hằng có tên (hằng ký hiệu): là các hằng phải định nghĩa trước khi sử dụng, tên của hằng đặt theo quy tắc của tên.
Định nghĩa hằng
Cú pháp:
const <kiểu_dữ_liệu> <tên_hằng> = <giá_trị>;
hoặc
const <tên_hằng> = <giá_trị>;
Ví dụ:
const int a = 5; // định nghĩa hằng a kiểu nguyên, có giá trị là 5
const float x = 4; // hằng x kiểu thực, có giá trị là 4.0
const d = 7; // hằng d kiểu int, giá trị là 7
const c = ‘1’; // hằng c kiểu int giá trị = 49
const char * s = “C++”;// s là hằng con trỏ, trỏ tới xâu “C++”
Chú ý: Các hằng số trong C++ được ngầm hiểu là hệ 10, nhưng ta có thể viết các hằng trong hệ 16 hoặc 8 bằng cú pháp, giá trị số hệ 16 được bắt đầu bằng 0x, ví dụ như 0x24, 0xA, các số hệ 8 bắt đầu bởi số 0, ví dụ 025, 057.
Các hằng kí tự được viết trong cặp dấu nháy đơn ‘’ :  ví dụ ‘a’, ‘2’ các giá trị này được C++ hiểu là số nguyên có giá trị bằng mã của kí tự; ‘a’ có giá trị là 97, ‘B’ có giá trị bằng 66.
Các xâu kí tự là dãy các kí tự được viết trong cặp dấu nháy kép “”, ví dụ “Ngon ngu C”, “a” (là kiểu xâu kí tự ).
Các phép toán của C++
Xuất nhập dữ liệu
Xuất dữ liệu (cout)
Ví dụ
cout << “Khoa CNTT”; // Hiển thị Khoa CNTT lên màn hình
cout << 120; // Hiển thị số 120 lên màn hình
cout << x; // Hiển thị nội dung biến x lên màn hình
Toán tử << được gọi là toán tử chèn vì nó chèn dữ liệu đi sau nó vào dòng dữ liệu đứng trước.
Chú ý: Nếu nội dung hiển thị là chuỗi ký tự thì phải đặt trong dấu ngoặc kép để phân biệt với các biến.
Ví dụ:
cout << “Hello”; // Hiển thị Hello lên màn hình
cout << Hello; // Hiển thị nội dung của biến Hello lên màn hình
Toán tử chèn (<<) có thể được sử dụng nhiều lần trong một câu lệnh
Ví dụ:
cout << “Hello, ” << “I am ” << “a C++ sentence”;
cout << “Hello, I am ” << age << ” years old and my email address is ” << email_add;
Chú ý: cout không nhảy xuống dòng sau khi xuất dữ liệu vì vậy muốn xuống dòng ta phải dùng ký tự \n
Ví dụ:
cout << “First sentence.\n “;
cout << “Second sentence.\nThird sentence.”;
            Nhập dữ liệu (cin)
C++ sử dụng toán tử >> với dòng lệnh cin để nhập dữ liệu. Theo sau toán tử >>, biến sẽ lưu trữ dữ liệu được đọc vào.
Ví dụ: cin >> diemtoan;
cin chỉ bắt đầu xử lý dữ liệu nhập từ bàn phím sau khi phím Enter được gõ.
By dungkcna113 Posted in C/C++

CHƯƠNG 03 – GIỚI THIỆU NGÔN NGỮ LẬP TRÌNH C++

 

Lịch sử hình thành

Ngôn ngữ lập trình C do Dennis Ritchie nghĩ ra khi ông làm việc tại AT&T Bell Laboratories vào năm 1972.
C là một ngôn ngữ mạnh và có tính linh hoạt, nó đã nhanh chóng được sử dụng một cách rộng rãi, vượt ra khỏi phạm vi của Bell Labs. Các lập trình viên ở khắp mọi nơi bắt đầu sử dụng nó để viết tất cả các loại chương trình.
C++ được biết đến như là ngôn ngữ mới bao trùm lên C và do Bjarne Stroustrup sáng tác năm 1980 cũng tại phòng thí nghiệm Bell tại bang New Jersey, Mỹ. Ban đầu được ông đặt tên cho nó là “C with classes” (C với các lớp). Tuy nhiên đến năm 1983 thì ông đổi tên thành C++, trong đó ++ là toán tử tăng thêm 1 của C.
C++ được biết đến như là ngôn ngữ lập trình hướng sự vật hay hướng đối tượng – OOP (Object Oriented Programming).
Đặc Điểm
C là một ngôn ngữ mạnh và linh hoạt. C được sử dụng trong nhiều dự án khác nhau, như viết hệ điều hành, chương trình xử lý văn bản, đồ hoạ, bảng tính, và thậm chí cả chương trình dịch cho các ngôn ngữ khác.
C có sẵn rất nhiều các trình biên dịch (compiler) và các thư viện được viết sẵn khác.
C là một ngôn ngữ khả chuyển (portable language). Nghĩa là một chương trình viết bằng C cho một hệ máy tính (ví dụ như IBM PC) có thể được dịch và chạy trên hệ máy tính khác (chẳng hạn như DEC VAX) chỉ với rất ít các sử đổi. Tính khả chuyển đã được bởi chuẩn ANSI cho C.
C chỉ gồm một số ít từ khoá (keywords) làm nền tảng để xây dựng các các chức năng của ngôn ngữ.
C là ngôn ngữ lập trình theo modul. Mã chương trình C có thể (và nên) được viết thành các thủ tục gọi là function. Những function này có thể được sử dụng lại trong các ứng dụng (application) và chương trình khác nhau. Tuy nhiên C không cho phép khai báo hàm trong hàm.
C++ bao trùm lên C nên mọi đặc điểm của C đều có trong C++. Ngoài ra, C++ còn có một số đặc điểm khác như:
C++ là ngôn ngữ hướng đối tượng.
C++ là ngôn ngữ định kiểu rất mạnh.
C++ cung cấp cách truyền tham số bằng tham chiếu cho hàm.
C++ cung cấp cơ cấu thư viện để người lập trình có thể tự tạo thêm hàm thông dụng vào thư viện và có thể tái sử dụng sau này.
C++ cung cấp một cơ chế đa dạng hóa tên hàm và toán tử.
C++ cung cấp các class là loại cấu trúc mới đóng gói chung cho cả dữ liệu lẫn các hàm trong một chủ thể được bảo vệ một cách chặt chẽ.
Cấu trúc của một chương trình C++
(1):  Khai báo thư viện
(2): [Khai báo các nguyên mẫu hàm của người dùng].
(3): [Các định nghĩa kiểu].
(4): [Các định nghĩa Macro].
(5): [Các định nghĩa biến, hằng].
(6): <kiểu hàm> main ([khai báo tham số]).
(7): {
(8): Thân hàm main
(9): }
(10): Các định nghĩa hàm của người dùng.
Chú ý: Các thành phần trong cặp ngoặc vuông [] có thể có hoặc không trong chương trình.
Giải thích cú pháp:
(1): Cú pháp để khai báo thư viện: #include<tên_thư_viên.h>
       Ví dụ: #include<iostream.h>; #include<conio.h>;…
(2): Cung cấp tên hàm, kiểu hàm, số đối số và kiểu của từng đối số của hàm.
Cú pháp khai báo nguyên mẫu hàm: <kiểu hàm> <tên hàm> ([Khai báo các đối số]);
Ví dụ: int   chanle (int    x); Trong đó, kiểu hàm là int, tên hàm là chanle, đối số là x và kiểu của đối số là int.
 (3): Định nghĩa kiểu mới
Ngoài những kiểu chuẩn đã được cung cấp sẵn của ngôn ngữ, người lập trình có thể định nghĩa ra các kiểu mới từ những kiểu đã có bằng cách sử dụng từ khóa typedef.
(4): Định nghĩa Macro
(5): Các định nghĩa biến, hằng: Các biến và hằng được định nghĩa tại đây sẽ trở thành biến và hằng toàn cục.
 (6) – (9): Hàm main():Đây là thành phần bắt buộc trong một chương trình C++, thân của hàm main bắt đầu từ sau dấu mở móc { (dòng 7) cho tới dấu đóng móc } (dòng 9).
(10): Các định nghĩa hàm của người dùng: Một định nghĩa hàm bao gồm tiêu đề của hàm, thân hàm với cú pháp như sau:
<Kiểu hàm> <Tên hàm> ([Khai báo các đối])
{
<Thân hàm>
}
Ví dụ 1: Chương trình nhập vào điểm 3 môn: Toán, Lý, Hóa và tính điểm trung bình của 3 môn đó.
            //Khai báo thư viện
#include<iostream.h>
//Bắt đầu hàm main
int main()
{
//Khai báo 3 biến
double  dtb,dt,dl,dh;
//Nhập vào 3 điểm Toán, Lý, Hóa
cout<<“Diem toan la:”;
cin>>dt;
cout<<“diem ly la:”; cin>>dl;
cout<<“Diem hoa la:”; cin>>dh;
dtb = (dt+dl+dh)/3;
cout<<“diem trung binh 3 mon la:”<<“=”<<dtb<<“\n”;
if (dtb<5)
            cout<<“Hoc luc yeu“;
if (dtb>=5&&dtb<7)
                        cout<<“Hoc luc trung binh”;
if (dtb>=7 && dtb<=8)
                        cout<<“Hoc luc kha”;
else
                        cout<<“Hoc luc gioi”;
return 0;
}    //Kết thúc hàm main
By dungkcna113 Posted in C/C++

CHƯƠNG 02 – THUẬT TOÁN

 

VD:

+ Thuật toán giải phương trình bậc 1, giải phương trình bậc 2.
+ Thuật toán tìm số lớn nhất trong 3 số a, b, c.
+ Thuật toán tính trung bình cộng của 4 số a, b, c, d.
+ Thuật toán tìm đường đi ngắn nhất.
Khái Niệm
Thuật ngữ thuật toán (Algorithm) là từ viết tắt của tên một nhà toán học ở thế kỷ IX: Abu Ja’fa Mohammed ibn Musa al-Khowarizmi.
Thuật toán là một dãy hữu hạn các thao tác được bố trí theo một trình tự xác định, được đề ra trước, nhằm giải quyết một bài toán nhất định.
Thao tác hay còn gọi là tác vụ, phép toán (Operation) hay lệnh (Command), chỉ thị (Instruction)… là một hành động cần được thực hiện bởi cơ chế thực hiện thuật toán.
Mỗi thao tác biến đổi bài toán từ một trạng thái trước (hay trạng thái nhập) sang trạng thái sau (hay trạng thái xuất). Thực tế mỗi thao tác thường sử dụng một số đối tượng trong trạng thái nhập (các đối tượng nhập) và sản sinh ra các đối tượng mới trong trạng thái xuất (các đối tượng xuất). Quan hệ giữa 2 trạng thái xuất và nhập cho thấy tác động của thao tác. Dãy các thao tác của thuật toán nối tiếp nhau nhằm biến đổi bài toán từ trạng thái ban đầu đến trạng thái kết quả.
Các đặc trưng của thuật toán
Tính xác định: Các thao tác, các đối tượng, phương tiện trong thuật toán phải có ý nghĩa rõ ràng, không được gây nhầm lẫn. Nói cách khác, hai cơ chế hoạt động khác nhau cùng thực hiện một thuật toán, sử dụng các đối tượng, phương tiện nhập phải cho cùng một kết quả.
Tính dừng: Đòi hỏi thuật toán phải dừng và cho kết quả sau một số hữu hạn các bước.
Tính đúng của thuật toán: Thuật toán đúng là thuật toán cho kết quả thỏa mãn đặc tả thuật toán với mọi trường hợp của các đối tượng, phương tiện nhập.
Tính phổ dụng: Thuật toán để giải một lớp bài toán gồm nhiều bài cụ thể, lớp đó được xác định bởi đặc tả. Dĩ nhiên là có lớp bài toán chỉ gồm 1 bài. Thuật toán khi đó sẽ không cần sử dụng đối tượng, phương tiện nhập nào cả.
Phương pháp biểu diễn
Thuật toán có thể diễn đạt dưới nhiều hình thức, chẳng hạn dưới dạng lưu đồ, dạng ngôn ngữ tự nhiên, dạng mã giả hoặc một ngôn ngữ lập trình nào khác.
Dạng ngôn ngữ tự nhiên: Thuật toán có thể trình bày dưới dạng ngôn ngữ tự nhiên theo trình tự các bước thực hiện trong thuật toán.
Dạng ngôn ngữ lập trình: Dùng cấu trúc lệnh, dữ liệu của một ngôn ngữ lập trình nào đó để mô tả.
Dạng mã giả: Thuật toán trình bày trong dạng văn bản bằng ngôn ngữ tự nhiên tuy dễ hiểu nhưng khó cài đặt. Dùng một ngôn ngữ lập trình nào đó để diễn tả thì phức tạp, khó hiểu. Thông thường thuật toán cũng được trao đổi dưới dạng văn bản – tuy không ràng buộc nhiều vào cú pháp xác định như các ngôn ngữ lập trình, nhưng cũng tuân theo một số quy ước ban đầu – ta gọi là dạng mã giả. Tùy theo việc định hướng cài đặt thuật toán theo ngôn ngữ lập trình nào ta diễn đạt thuật toán gần với ngôn ngữ ấy.
Dạng lưu đồ: Trong các phương pháp biểu diễn, chúng ta sẽ chủ yếu nghiên cứu phương pháp biểu diễn theo dạng này. Dạng lưu đồ dùng các hình vẽ (có quy ước) để diễn đạt thuật toán. Lưu đồ cho hình ảnh trực quan và tổng thể của thuật toán, cho nên thường được sử dụng nhiều nhất.
Các ký hiệu sử dụng trong phương pháp biểu diễn thuật toán bằng lưu đồ:

Chú ý khi vẽ lưu đồ:

+ Trước tiên hãy tập trung vẽ một số đường đi chính của lưu đồ.
+ Thêm vào tất cả các nhánh và vòng lặp.
+ Một lưu đồ chỉ có một điểm Bắt đầu và một điểm kết thúc.
+ Mỗi bước trong chương trình không cần thể hiện trong lưu đồ.
+ Lưu đồ cần phải đáp ứng được yêu cầu: những người lập trình khác có thể hiểu lưu đồ một cách dễ dàng.
VD: Đọc các thông tin như tên, tuối và lưu lại những người có tuổi trên 50
 
By dungkcna113 Posted in C/C++