Unsigned integers là gì? và tại sao phải tránh dùng nó

2666

 

  10 tài liệu C++ đáng đọc nhất
  Thiết kế chương trình dựa trên khái niệm Function C/C++

Unsigned integers (Số nguyên không dấu)

Trong bài học trước (Số nguyên có ký hiệu(có dấu) hay còn gọi là số nguyên), chúng ta đã đề cập đến các số nguyên có ký hiệu, là một tập hợp các kiểu dữ liệu có thể chứa các số nguyên dương và âm, bao gồm 0.

C ++ cũng hỗ trợ các số nguyên không dấu. Số nguyên không dấu là số nguyên chỉ có thể chứa các số nguyên không âm.

Định nghĩa số nguyên không dấu

Để nghĩa một số nguyên không dấu, chúng tôi sử dụng từ khóa unsigned. Theo quy ước, điều này được đặt trước kiểu dữ liệu:

1
2
3
4
unsigned short us;
unsigned int ui;
unsigned long ul;
unsigned long long ull;

Phạm vi của số nguyên không dấu

Số nguyên không dấu 1 byte có phạm vi từ 0 đến 255. So sánh giá trị này với phạm vi số nguyên có ký hiệu thì 1 byte từ -128 đến 127. Cả hai có thể lưu trữ 256 giá trị khác nhau, nhưng số nguyên có ký hiệu sẽ sử dụng một nửa phạm vi của chúng cho các số âm, trong khi số nguyên không dấu có thể lưu trữ số dương lớn gấp đôi.

Ở đây, một bảng hiển thị phạm vi cho các số nguyên không dấu:

Size/Type Range
1 byte unsigned 0 to 255
2 byte unsigned 0 to 65,535
4 byte unsigned 0 to 4,294,967,295
8 byte unsigned 0 to 18,446,744,073,709,551,615

Một biến không dấu n-bit có phạm vi từ 0 đến (2n) -1.

Khi không yêu cầu số âm, số nguyên không dấu rất phù hợp cho mạng và hệ thống có ít bộ nhớ, bởi vì số nguyên không dấu có thể lưu trữ số dương nhiều hơn mà không chiếm thêm bộ nhớ.

Các điều cần ghi nhớ của số nguyên có và không có dấu

Lập trình viên mới đôi khi lẫn lộn giữa số nguyên có và không có dấu. Sau đây là một cách đơn giản để ghi nhớ sự khác biệt: để phân biệt số âm với số dương, chúng tôi sử dụng dấu âm. Nếu một số mà không có ký hiệu âm or dương(+, -) thì chúng ta giả sử đó một số là dương. Do đó, một số nguyên có dấu (số nguyên có ký hiệu) có thể có giá trị là dương và âm. Một số nguyên không có dấu (số nguyên không dấu) thì các giá trị đều là dương.

Tràn số nguyên không dấu

Câu hỏi mẹo: Điều gì xảy ra nếu chúng ta cố lưu trữ số 280 (yêu cầu 9 bit để biểu diễn) trong một số nguyên không dấu 1 byte? Bạn có thể nghĩ rằng câu trả lời là tràn ngập! Nhưng, nó không tràn.

Theo định nghĩa, số nguyên không dấu không thể tràn.

Chúng ta hãy xem xét điều này bằng cách sử dụng các số nguyên 2 byte:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
 
int main()
{
    unsigned short x{ 65535 }; // largest 16-bit unsigned value possible
    std::cout << "x was: " << x << '\n';
 
    x = 65536; // 65536 is out of our range, so we get wrap-around
    std::cout << "x is now: " << x << '\n';
 
    x = 65537; // 65537 is out of our range, so we get wrap-around
    std::cout << "x is now: " << x << '\n';
 
    return 0;
}

Bạn nghĩ kết quả của chương trình này sẽ là gì?

1
2
3
x was: 65535
x is now: 0
x is now: 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
 
int main()
{
    unsigned short x{ 0 }; // smallest 2-byte unsigned value possible
    std::cout << "x was: " << x << '\n';
 
    x = -1; // -1 is out of our range, so we get wrap-around
    std::cout << "x is now: " << x << '\n';
 
    x = -2; // -2 is out of our range, so we get wrap-around
    std::cout << "x is now: " << x << '\n';
 
    return 0;
}
1
2
3
x was: 0
x is now: 65535
x is now: 65534

Cuộc tranh cãi về số nguyên không dấu

Nhiều developer(và một số developer lớn, như Google) tin rằng các developer thường nên tránh các số nguyên không dấu.

Điều này phần lớn là do hai hành vi sau đây có thể gây ra vấn đề.

Đầu tiên, hãy xem xét phép trừ của hai số không dấu, chẳng hạn như 3 và 5. 3 trừ 5 là -2, nhưng -2 có thể được biểu diễn dưới dạng một số không dấu như sau.

1
2
3
4
5
6
7
8
9
10
#include <iostream>
 
int main()
{
    unsigned int x{ 3 };
    unsigned int y{ 5 };
 
    std::cout << x - y << '\n';
    return 0;
}

Chương trình tạo ra kết quả như sau:

1
4294967294

Thứ hai, hành vi không mong muốn có thể dẫn đến khi bạn trộn các số nguyên có dấu và không dấu. Trong ví dụ trên, ngay cả khi một trong các toán hạng (x hoặc y) có dấu, toán hạng khác (không dấu) sẽ làm cho toán tử có dấu được chuyển thành thành một số nguyên không dấu, và hành vi này sẽ dẫn đến kết quả không mong đợi.

Hãy xem xét đoạn trích sau:

1
2
3
4
5
6
7
8
9
10
11
void doSomething(unsigned int x)
{
    // Run some code x times
}
 
int main()
{
    doSomething(-1);
 
    return 0;
}

Tác giả của doSomething() đã mong đợi ai đó gọi hàm này chỉ bằng số dương. Nhưng người gọi đang chuyển qua -1. Điều gì xảy ra trong trường hợp này?

Đối số có dấu của -1 được chuyển đổi hoàn toàn thành tham số không dấu. -1 không nằm trong phạm vi của một số không dấu, vì vậy nó bao quanh một số lớn (có thể là 4294967295). Sau đó, chương trình của bạn sẽ cho ra kq sai. Tồi tệ hơn, không có cách nào tốt để bảo vệ chống lại tình trạng này xảy ra. C ++ sẽ tự do chuyển đổi giữa các số có dấu và không dấu.

Nếu bạn cần bảo vệ một hàm chống lại các đầu vào tiêu cực, thay vào đó hãy sử dụng một xác nhận hoặc ngoại lệ. Cả hai đều được bảo vệ điều này.

Một số ngôn ngữ lập trình hiện đại (như Java) và các framework (như .NET) hoặc không bao gồm các kiểu không dấu hoặc giới hạn việc sử dụng chúng.

Các lập trình viên mới thường sử dụng các số nguyên không dấu để thể hiện dữ liệu không âm hoặc để tận dụng phạm vi bổ sung. Bjarne Stroustrup, nhà thiết kế của C ++, cho biết, sử dụng số nguyên không dấu thay vì có dấu để có thêm một bit để biểu diễn các số nguyên dương gần như không phải là một ý tưởng hay.

Lưu ý: Tránh sử dụng số không dấu, trừ trường hợp cụ thể hoặc khi không thể tránh khỏi.

Nếu bạn sử dụng số không dấu, tránh trộn lẫn các số có dấu và không dấu nếu có thể.

Vậy đâu khi nào là hợp lý để sử dụng số không dấu?

Vẫn còn một vài trường hợp trong C ++ sử dụng các số không dấu (hoặc cần thiết).

Đầu tiên, các số không dấu được ưa thích khi xử lý thao tác bit.

Thứ hai, việc sử dụng các số không dấu vẫn không thể tránh khỏi trong một số trường hợp, chủ yếu là những việc phải làm với lập index cho mảng. Chúng ta sẽ nói nhiều hơn về điều này trong các bài học về mảng và lập index cho mảng.

Cũng lưu ý rằng nếu bạn đang phát triển cho một hệ thống nhúng (ví dụ: Arduino) hoặc một số bối cảnh giới hạn bộ xử lý / bộ nhớ khác, việc sử dụng các số không dấu là phổ biến hơn và được chấp nhận (và trong một số trường hợp, không thể tránh khỏi) vì lý do hiệu suất.

TechTalk via CafeDev

CHIA SẺ